From 6db2dce051eff001da9527de31a6415117a6e741 Mon Sep 17 00:00:00 2001 From: dizcza Date: Wed, 16 Dec 2020 15:42:40 +0100 Subject: [PATCH 01/63] fix bibtex v1 (until all citations are in bibtex) --- requirements/requirements-docs.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements-docs.txt b/requirements/requirements-docs.txt index 2e7d10072..654dda7f7 100644 --- a/requirements/requirements-docs.txt +++ b/requirements/requirements-docs.txt @@ -3,7 +3,7 @@ numpydoc>=1.1.0 jupyter>=1.0.0 sphinx>=3.3.0 nbsphinx>=0.8.0 -sphinxcontrib-bibtex>=1.0.0 +sphinxcontrib-bibtex==1.0.0 sphinx-tabs>=1.3.0 matplotlib>=3.3.2 # conda install -c conda-forge pandoc From 25d4b1e5fdab386901beb947a87582c8704f1924 Mon Sep 17 00:00:00 2001 From: maximilian_kramer <56024817+ojoenlanuca@users.noreply.github.com> Date: Mon, 21 Dec 2020 13:07:26 +0100 Subject: [PATCH 02/63] Feature/plv (#385) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * phase_locking_value * mean_phase_vector * phase_difference Co-authored-by: dizcza Co-authored-by: Cristiano Köhler --- doc/authors.rst | 1 + elephant/phase_analysis.py | 127 +++++++++++++++++++- elephant/test/test_phase_analysis.py | 168 +++++++++++++++++++++++++++ 3 files changed, 295 insertions(+), 1 deletion(-) diff --git a/doc/authors.rst b/doc/authors.rst index 48e81b1c0..3172802fe 100644 --- a/doc/authors.rst +++ b/doc/authors.rst @@ -51,6 +51,7 @@ Do you want to contribute to Elephant? Please refer to the * Regimantas Jurkus [1] * Philipp Steigerwald [12] * Manuel Ciba [12] +* Maximilian Kramer [1] 1. Institute of Neuroscience and Medicine (INM-6), Computational and Systems Neuroscience & Institute for Advanced Simulation (IAS-6), Theoretical Neuroscience, Jülich Research Centre and JARA, Jülich, Germany 2. Unité de Neurosciences, Information et Complexité, CNRS UPR 3293, Gif-sur-Yvette, France diff --git a/elephant/phase_analysis.py b/elephant/phase_analysis.py index aa3a73345..276681900 100644 --- a/elephant/phase_analysis.py +++ b/elephant/phase_analysis.py @@ -10,9 +10,13 @@ import numpy as np import quantities as pq +import neo __all__ = [ - "spike_triggered_phase" + "spike_triggered_phase", + "phase_locking_value", + "mean_phase_vector", + "phase_difference" ] @@ -182,3 +186,124 @@ def spike_triggered_phase(hilbert_transform, spiketrains, interpolate): for i, entry in enumerate(result_times): result_times[i] = pq.Quantity(entry, units=entry[0].units).flatten() return result_phases, result_amps, result_times + + +def phase_locking_value(phases_i, phases_j): + r""" + Calculates the phase locking value (PLV). + + This function expects the phases of two signals (each containing multiple + trials). For each trial pair, it calculates the phase difference at each + time point. Then it calculates the mean vectors of those phase differences + across all trials. The PLV at time `t` is the length of the corresponding + mean vector. + + Parameters + ---------- + phases_i, phases_j : (t, n) np.ndarray + Time-series of the first and second signals, with `t` time points and + `n` trials. + + Returns + ------- + plv : (t,) np.ndarray + Vector of floats with the phase-locking value at each time point. + Range: :math:`[0, 1]` + + Raises + ------ + ValueError + If the shapes of `phases_i` and `phases_j` are different. + + Notes + ----- + This implementation is based on the formula taken from [1] (pp. 195): + + .. math:: + PLV_t = \frac{1}{N} \left | + \sum_{n=1}^N \exp(i \cdot \theta(t, n)) \right | \\ + + where :math:`\theta(t, n) = \phi_x(t, n) - \phi_y(t, n)` + is the phase difference at time `t` for trial `n`. + + References + ---------- + [1] Jean-Philippe Lachaux, Eugenio Rodriguez, Jacques Martinerie, + and Francisco J. Varela, "Measuring Phase Synchrony in Brain Signals" + Human Brain Mapping, vol 8, pp. 194-208, 1999. + """ + if np.shape(phases_i) != np.shape(phases_j): + raise ValueError("trial number and trial length of signal x and y " + "must be equal") + + # trial by trial and time-resolved + # version 0.2: signal x and y have multiple trials + # with discrete values/phases + + phase_diff = phase_difference(phases_i, phases_j) + theta, r = mean_phase_vector(phase_diff, axis=0) + return r + + +def mean_phase_vector(phases, axis=0): + r""" + Calculates the mean vector of phases. + + This function expects phases (in radians) and uses their representation as + complex numbers to calculate the direction :math:`\theta` and the length + `r` of the mean vector. + + Parameters + ---------- + phases : np.ndarray + Phases in radians. + axis : int, optional + Axis along which the mean vector will be calculated. + If None, it will be computed across the flattened array. + Default: 0 + + Returns + ------- + z_mean_theta : np.ndarray + Angle of the mean vector. + Range: :math:`(-\pi, \pi]` + z_mean_r : np.ndarray + Length of the mean vector. + Range: :math:`[0, 1]` + """ + # use complex number representation + # z_phases = np.cos(phases) + 1j * np.sin(phases) + z_phases = np.exp(1j * np.asarray(phases)) + z_mean = np.mean(z_phases, axis=axis) + z_mean_theta = np.angle(z_mean) + z_mean_r = np.abs(z_mean) + return z_mean_theta, z_mean_r + + +def phase_difference(alpha, beta): + r""" + Calculates the difference between a pair of phases. + + The output is in range from :math:`-\pi` to :math:`\pi`. + + Parameters + ---------- + alpha : np.ndarray + Phases in radians. + beta : np.ndarray + Phases in radians. + + Returns + ------- + phase_diff : np.ndarray + Difference between phases `alpha` and `beta`. + Range: :math:`[-\pi, \pi]` + + Notes + ----- + The usage of `np.arctan2` ensures that the range of the phase difference + is :math:`[-\pi, \pi]` and is located in the correct quadrant. + """ + delta = alpha - beta + phase_diff = np.arctan2(np.sin(delta), np.cos(delta)) + return phase_diff diff --git a/elephant/test/test_phase_analysis.py b/elephant/test/test_phase_analysis.py index 8385e3cc7..dfa94a690 100644 --- a/elephant/test/test_phase_analysis.py +++ b/elephant/test/test_phase_analysis.py @@ -202,5 +202,173 @@ def test_regression_269(self): self.assertEqual(len(phases_noint[0]), 2) +class MeanVectorTestCase(unittest.TestCase): + def setUp(self): + self.tolerance = 1e-15 + self.n_samples = 200 + # create a sample with all values equal to a random phase-lock phi + self.lock_value_phi = np.random.uniform(-np.pi, np.pi, 1) + self.dataset1 = np.ones(self.n_samples) * self.lock_value_phi + # create a evenly spaced / uniform distribution + self.dataset2 = np.arange(0, 2 * np.pi, (2 * np.pi) / self.n_samples) + # create a random distribution + self.dataset3 = np.random.uniform(-np.pi, np.pi, self.n_samples) + + def testMeanVector_direction_is_phi_and_length_is_1(self): + """ + Test if the mean vector length is 1 and if the mean direction is phi + for a sample with all phases equal to phi on the unit circle. + + """ + theta_bar_1, r_1 = elephant.phase_analysis.mean_phase_vector( + self.dataset1) + # mean direction must be phi + self.assertAlmostEqual(theta_bar_1, self.lock_value_phi, + delta=self.tolerance) + # mean vector length must be almost equal 1 + self.assertAlmostEqual(r_1, 1, delta=self.tolerance) + + def testMeanVector_length_is_0(self): + """ + Test if the mean vector length is 0 for a evenly spaced distribution + on the unit circle. + """ + theta_bar_2, r_2 = elephant.phase_analysis.mean_phase_vector( + self.dataset2) + # mean vector length must be almost equal 0 + self.assertAlmostEqual(r_2, 0, delta=self.tolerance) + + def testMeanVector_ranges_of_direction_and_length(self): + """ + Test if the range of the mean vector direction follows numpy standard + and is within (-pi, pi]. + Test if the range of the mean vector length is within [0, 1]. + """ + theta_bar_3, r_3 = elephant.phase_analysis.mean_phase_vector( + self.dataset3) + # mean vector direction + self.assertTrue(-np.pi < theta_bar_3 <= np.pi) + # mean vector length + self.assertTrue(0 <= r_3 <= 1) + + +class PhaseDifferenceTestCase(unittest.TestCase): + def setUp(self): + self.tolerance = 1e-15 + self.n_samples = 200 + + def testPhaseDifference_in_range_minus_pi_to_pi(self): + """ + Test if the range of the phase difference is within [-pi, pi] for + random pairs of alpha and beta. + """ + alpha = np.random.uniform(-np.pi, np.pi, self.n_samples) + beta = np.random.uniform(-np.pi, np.pi, self.n_samples) + + phase_diff = elephant.phase_analysis.phase_difference(alpha, beta) + self.assertTrue((-np.pi <= phase_diff).all() + and (phase_diff <= np.pi).all()) + + def testPhaseDifference_is_delta(self): + """ + Test if the phase difference is random delta for random pairs of + alpha and beta, where beta is a copy of alpha shifted by delta. + """ + delta = np.random.uniform(-np.pi, np.pi, self.n_samples) + alpha = np.random.uniform(-np.pi, np.pi, self.n_samples) + _beta = alpha - delta + beta = np.arctan2(np.sin(_beta), np.cos(_beta)) + + phase_diff = elephant.phase_analysis.phase_difference(alpha, beta) + np.testing.assert_allclose(phase_diff, delta, atol=1e-10) + + +class PhaseLockingValueTestCase(unittest.TestCase): + def setUp(self): + self.tolerance = 1e-15 + self.phase_shift = np.pi / 4 + self.num_time_points = 1000 + self.num_trials = 100 + + # create two random uniform distributions (all trials are identical) + self.signal_x = \ + np.full([self.num_trials, self.num_time_points], + np.random.uniform(-np.pi, np.pi, self.num_time_points)) + self.signal_y = \ + np.full([self.num_trials, self.num_time_points], + np.random.uniform(-np.pi, np.pi, self.num_time_points)) + + # create two random uniform distributions, where all trails are random + self.random_x = np.random.uniform( + -np.pi, np.pi, (1000, self.num_time_points)) + self.random_y = np.random.uniform( + -np.pi, np.pi, (1000, self.num_time_points)) + + # simple samples of different shapes to assert ErrorRaising + self.simple_x = np.array([[0, -np.pi, np.pi], [0, -np.pi, np.pi]]) + self.simple_y = np.array([0, -np.pi, np.pi]) + self.simple_z = np.array([0, np.pi, np.pi / 2, -np.pi]) + + def testPhaseLockingValue_identical_signals_both_identical_trials(self): + """ + Test if the PLV's are 1, when 2 identical signals with identical + trials are passed. PLV's needed to be 1, due to the constant phase + difference of 0 across trials at each time-point. + """ + list1_plv_t = \ + elephant.phase_analysis.phase_locking_value(self.signal_x, + self.signal_x) + target_plv_r_is_one = np.ones_like(list1_plv_t) + np.testing.assert_allclose(list1_plv_t, target_plv_r_is_one, + self.tolerance) + + def testPhaseLockingValue_different_signals_both_identical_trials(self): + """ + Test if the PLV's are 1, when 2 different signals are passed, where + within each signal the trials are identical. PLV's needed to be 1, + due to a constant phase difference across trials, which may vary for + different time-points. + """ + list2_plv_t = elephant.phase_analysis.phase_locking_value( + self.signal_x, self.signal_y) + target_plv_r_is_one = np.ones_like(list2_plv_t) + np.testing.assert_allclose(list2_plv_t, target_plv_r_is_one, + atol=3e-15) + + def testPhaseLockingValue_different_signals_both_different_trials(self): + """ + Test if the PLV's are close to 0, when 2 different signals are passed, + where both have different trials, which are all randomly distributed. + The PLV's needed to be close to 0, do to a random + phase difference across trials for each time-point. + """ + list3_plv_t = elephant.phase_analysis.phase_locking_value( + self.random_x, self.random_y) + target_plv_is_zero = np.zeros_like(list3_plv_t) + # use default value from np.allclose() for atol=1e-8 to prevent failure + np.testing.assert_allclose(list3_plv_t, target_plv_is_zero, + rtol=1e-2, atol=1.1e-1) + + def testPhaseLockingValue_raise_Error_if_trial_number_is_different(self): + """ + Test if a ValueError is raised, when the signals have different + number of trails. + """ + # different numbers of trails + np.testing.assert_raises( + ValueError, elephant.phase_analysis.phase_locking_value, + self.simple_x, self.simple_y) + + def testPhaseLockingValue_raise_Error_if_trial_lengths_are_different(self): + """ + Test if a ValueError is raised, when within a trail-pair of the signals + the trial-lengths are different. + """ + # different lengths in a trail pair + np.testing.assert_raises( + ValueError, elephant.phase_analysis.phase_locking_value, + self.simple_y, self.simple_z) + + if __name__ == '__main__': unittest.main() From 352c04da36f080451f4392fea9e9b01291016236 Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Wed, 6 Jan 2021 09:44:53 +0100 Subject: [PATCH 03/63] Granger causality tutorial notebook (#393) --- doc/tutorials.rst | 7 + doc/tutorials/granger_causality.ipynb | 231 ++++++++++++++++++++++++++ elephant/causality/granger.py | 12 ++ 3 files changed, 250 insertions(+) create mode 100644 doc/tutorials/granger_causality.ipynb diff --git a/doc/tutorials.rst b/doc/tutorials.rst index 50d56e132..ff4abdcf3 100644 --- a/doc/tutorials.rst +++ b/doc/tutorials.rst @@ -54,6 +54,13 @@ Advanced .. image:: https://mybinder.org/badge.svg :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master?filepath=doc/tutorials/asset.ipynb +* Granger causality + + :doc:`View the notebook <../tutorials/granger_causality>` or run interactively: + + .. image:: https://mybinder.org/badge.svg + :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master?filepath=doc/tutorials/granger_causality.ipynb + Additional ---------- diff --git a/doc/tutorials/granger_causality.ipynb b/doc/tutorials/granger_causality.ipynb new file mode 100644 index 000000000..c677d657c --- /dev/null +++ b/doc/tutorials/granger_causality.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Time-domain Granger Causality\n", + "## Pairwise Granger Causality\n", + "The Granger causality is a method to determine functional connectivity between time-series using autoregressive modelling. In the simpliest pairwise Granger causality case for signals X and Y the data are modelled as autoregressive processes. Each of these processes has two representations. The first representation contains the history of the signal X itself and a prediction error (or noise a.k.a. residual), whereas the second also incorporates the history of the other signal. \n", + "\n", + "If inclusion of the history of Y next to the history of X into X model reduces the prediction error compared to just the history of X alone, Y is said to Granger cause X. The same can be done by interchanging the signals to determine if X Granger causes Y.\n", + "\n", + "## Conditional Granger Causality\n", + "Conditional Granger causality can be used to further investigate this functional connectivity. Given signals X, Y and Z, we find that Y Granger causes X, but we want to test if this causality is mediated through Z. We can use Z as a condition for the aforementioned Granger causality.\n", + "\n", + "In order to illustrate the function of time-domain Granger causality we will be using examples from Ding et al. (2006) chapter. Specifically, we will have two cases of three signals. In the first case we will have indirect connectivity only, whereas in the second case both direct and indirect connectivities will be present.\n", + "\n", + "References: Ding M., Chen Y. and Bressler S.L. (2006) Granger Causality: Basic Theory and Application to Neuroscience. https://arxiv.org/abs/q-bio/0608035\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from elephant.causality.granger import pairwise_granger, conditional_granger" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "# Indirect causal influence diagram\n", + "node1 = plt.Circle((0.2, 0.2), 0.1, color='red')\n", + "node2 = plt.Circle((0.5, 0.6), 0.1, color='red')\n", + "node3 = plt.Circle((0.8, 0.2), 0.1, color='red')\n", + "ax1.set_aspect(1)\n", + "ax1.arrow(0.28, 0.3, 0.1, 0.125, width=0.02, color='k')\n", + "ax1.arrow(0.6, 0.5, 0.1, -0.125, width=0.02, color='k')\n", + "ax1.add_artist(node1)\n", + "ax1.add_artist(node2)\n", + "ax1.add_artist(node3)\n", + "ax1.text(0.2, 0.2, 'Y', horizontalalignment='center', verticalalignment='center')\n", + "ax1.text(0.5, 0.6, 'Z', horizontalalignment='center', verticalalignment='center')\n", + "ax1.text(0.8, 0.2, 'X', horizontalalignment='center', verticalalignment='center')\n", + "ax1.set_title('Indirect only')\n", + "\n", + "ax1.tick_params(axis='both', which='both', bottom=False, top=False, labelbottom=False, \n", + " right=False, left=False, labelleft=False)\n", + "\n", + "# Both direct and indirect causal influence diagram\n", + "node1 = plt.Circle((0.2, 0.2), 0.1, color='g')\n", + "node2 = plt.Circle((0.5, 0.6), 0.1, color='g')\n", + "node3 = plt.Circle((0.8, 0.2), 0.1, color='g')\n", + "ax2.set_aspect(1)\n", + "ax2.arrow(0.28, 0.3, 0.1, 0.125, width=0.02, color='k')\n", + "ax2.arrow(0.35, 0.2, 0.2, 0.0, width=0.02, color='k')\n", + "ax2.arrow(0.6, 0.5, 0.1, -0.125, width=0.02, color='k')\n", + "ax2.add_artist(node1)\n", + "ax2.add_artist(node2)\n", + "ax2.add_artist(node3)\n", + "ax2.text(0.2, 0.2, 'Y', horizontalalignment='center', verticalalignment='center')\n", + "ax2.text(0.5, 0.6, 'Z', horizontalalignment='center', verticalalignment='center')\n", + "ax2.text(0.8, 0.2, 'X', horizontalalignment='center', verticalalignment='center')\n", + "\n", + "ax2.tick_params(axis='both', which='both', bottom=False, top=False, labelbottom=False, \n", + " right=False, left=False, labelleft=False)\n", + "ax2.set_title('Both direct and indirect')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_data(length=30000, causality_type=\"indirect\"):\n", + " \"\"\"\n", + " Recreated from Example 2 section 5.2 of :cite:'granger-Ding06-0608035'.\n", + " \n", + " Parameters\n", + " ----------\n", + " length : int\n", + " The length of the signals to be generated (i.e. shape(signal) = (3, length))\n", + " causality_type: str\n", + " Type of causal influence in the data:\n", + " 'indirect' for indirect causal influence only (i.e. Y -> Z -> X)\n", + " 'both' for direct and indirect causal influence\n", + " \n", + " \n", + " Notes\n", + " -----\n", + " Taken from elephant.test.test_causality.ConditionalGrangerTestCase\n", + "\n", + " \"\"\"\n", + " if causality_type == \"indirect\":\n", + " y_t_lag_2 = 0\n", + " elif causality_type == \"both\":\n", + " y_t_lag_2 = 0.2\n", + " else:\n", + " raise ValueError(\"causality_type should be either 'indirect' or \"\n", + " \"'both'\")\n", + "\n", + " order = 2\n", + " signal = np.zeros((3, length + order))\n", + "\n", + " weights_1 = np.array([[0.8, 0, 0.4],\n", + " [0, 0.9, 0],\n", + " [0., 0.5, 0.5]])\n", + "\n", + " weights_2 = np.array([[-0.5, y_t_lag_2, 0.],\n", + " [0., -0.8, 0],\n", + " [0, 0, -0.2]])\n", + "\n", + " weights = np.stack((weights_1, weights_2))\n", + "\n", + " noise_covariance = np.array([[0.3, 0.0, 0.0],\n", + " [0.0, 1., 0.0],\n", + " [0.0, 0.0, 0.2]])\n", + "\n", + " for i in range(length):\n", + " for lag in range(order):\n", + " signal[:, i + order] += np.dot(weights[lag],\n", + " signal[:, i + 1 - lag])\n", + " rnd_var = np.random.multivariate_normal([0, 0, 0],\n", + " noise_covariance)\n", + " signal[:, i + order] += rnd_var\n", + "\n", + " signal = signal[:, 2:]\n", + "\n", + " return signal.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Indirect causality" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(1)\n", + "\n", + "# Indirect causality\n", + "xyz_indirect_sig = generate_data(length=10000, causality_type='indirect')\n", + "xy_indirect_sig = xyz_indirect_sig[:, :2]\n", + "indirect_pairwise_gc = pairwise_granger(xy_indirect_sig, max_order=10, information_criterion='aic')\n", + "print(indirect_pairwise_gc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Indirect causality (conditioned on z)\n", + "indirect_cond_gc = conditional_granger(xyz_indirect_sig, max_order=10, information_criterion='aic')\n", + "print(indirect_cond_gc)\n", + "print('Zero value indicates total dependence on signal Z')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Both direct and indirect causality" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Both direct and indirect causality\n", + "xyz_both_sig = generate_data(length=10000, causality_type='both')\n", + "xy_both_sig = xyz_both_sig[:, :2]\n", + "both_pairwise_gc = pairwise_granger(xy_both_sig, max_order=10, information_criterion='aic')\n", + "print(both_pairwise_gc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Both direct and indirect causality (conditioned on z)\n", + "both_cond_gc = conditional_granger(xyz_both_sig, max_order=10, information_criterion='aic')\n", + "print(both_cond_gc)\n", + "print('Non-zero value indicates the presence of direct Y to X influence')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/elephant/causality/granger.py b/elephant/causality/granger.py index f09438866..a6a68e89e 100644 --- a/elephant/causality/granger.py +++ b/elephant/causality/granger.py @@ -48,6 +48,18 @@ conditional_granger +Tutorial +-------- + +:doc:`View tutorial <../tutorials/granger_causality>` + +Run tutorial interactively: + +.. image:: https://mybinder.org/badge.svg + :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master + ?filepath=doc/tutorials/granger_causality.ipynb + + References ---------- From 6193e665f536f5b806f8f635c1245d9619ed234f Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Wed, 6 Jan 2021 09:48:30 +0100 Subject: [PATCH 04/63] Unitary Event Analysis support multiple pattern hashes (#387) * UEA store input_parameters * fixed UEA test files download * support multiple hashes * UEA default pattern_hash * fixed UEA tutorial (borrowed from viziphant) --- doc/tutorials/unitary_event_analysis.ipynb | 500 +++++++++++++------ elephant/test/download.py | 31 +- elephant/test/test_spike_train_synchrony.py | 4 +- elephant/test/test_unitary_event_analysis.py | 149 ++++-- elephant/unitary_event_analysis.py | 275 +++++----- 5 files changed, 603 insertions(+), 356 deletions(-) diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 8a92f5d67..48855eda4 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -43,6 +43,7 @@ "outputs": [], "source": [ "import random\n", + "import string\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import quantities as pq\n", @@ -97,164 +98,352 @@ }, "outputs": [], "source": [ - "def plot_UE(data,Js_dict,Js_sig,bin_size,winsize,winstep, pat,N,t_winpos,**kwargs):\n", + "# borrowed from Viziphant\n", + "\n", + "plot_params_default = {\n", + " # epochs to be marked on the time axis\n", + " 'events': {},\n", + " # figure size\n", + " 'figsize': (10, 12),\n", + " # right margin\n", + " 'right': 0.9,\n", + " # top margin\n", + " 'top': 0.9,\n", + " # bottom margin\n", + " 'bottom': 0.1,\n", + " # left margin\n", + " 'left': 0.1,\n", + " # horizontal white space between subplots\n", + " 'hspace': 0.5,\n", + " # width white space between subplots\n", + " 'wspace': 0.5,\n", + " # font size\n", + " 'fsize': 12,\n", + " # the actual unit ids from the experimental recording\n", + " 'unit_real_ids': None,\n", + " # line width\n", + " 'lw': 2,\n", + " # marker size for the UEs and coincidences\n", + " 'ms': 5,\n", + " # figure title\n", + " 'suptitle': None,\n", + "}\n", + "\n", + "\n", + "def plot_ue(spiketrains, Js_dict, significance_level=0.05,\n", + " **plot_params):\n", " \"\"\"\n", - " Examples:\n", - " ---------\n", - " dict_args = {'events':{'SO':[100*pq.ms]},\n", - " 'save_fig': True,\n", - " 'path_filename_format':'UE1.pdf',\n", - " 'showfig':True,\n", - " 'suptitle':True,\n", - " 'figsize':(12,10),\n", - " 'unit_ids':[10, 19, 20],\n", - " 'ch_ids':[1,3,4],\n", - " 'fontsize':15,\n", - " 'linewidth':2,\n", - " 'set_xticks' :False'}\n", - " 'marker_size':8,\n", + " Plots the results of pairwise unitary event analysis as a column of six\n", + " subplots, comprised of raster plot, peri-stimulus time histogram,\n", + " coincident event plot, coincidence rate plot, significance plot and\n", + " unitary event plot, respectively.\n", + "\n", + " Parameters\n", + " ----------\n", + " spiketrains : list of list of neo.SpikeTrain\n", + " A nested list of trials, neurons and their neo.SpikeTrain objects,\n", + " respectively. This should be identical to the one used to generate\n", + " Js_dict.\n", + " Js_dict : dict\n", + " The output of\n", + " :func:`elephant.unitary_event_analysis.jointJ_window_analysis`\n", + " function. The values of each key has the shape of:\n", + "\n", + " * different window --> 0-axis.\n", + " * different pattern hash --> 1-axis;\n", + "\n", + " Dictionary keys:\n", + "\n", + " 'Js': list of float\n", + " JointSurprise of different given patterns within each window.\n", + " 'indices': list of list of int\n", + " A list of indices of pattern within each window.\n", + " 'n_emp': list of int\n", + " The empirical number of each observed pattern.\n", + " 'n_exp': list of float\n", + " The expected number of each pattern.\n", + " 'rate_avg': list of float\n", + " The average firing rate of each neuron.\n", + "\n", + " significance_level : float\n", + " The significance threshold used to determine which coincident events\n", + " are classified as unitary events within a window.\n", + " **plot_params\n", + " User-defined plotting parameters used to update the default plotting\n", + " parameter values. The valid keys:\n", + "\n", + " 'events' : list\n", + " Epochs to be marked on the time axis.\n", + " 'figsize' : tuple of int\n", + " The dimensions for the figure size.\n", + " 'right' : float\n", + " The size of the right margin.\n", + " 'top' : float\n", + " The size of the top margin.\n", + " 'bottom' : float\n", + " The size of the bottom margin.\n", + " 'left' : float\n", + " The size of the left margin.\n", + " 'hspace' : flaot\n", + " The size of the horizontal white space between subplots.\n", + " 'wspace' : float\n", + " The width of the white space between subplots.\n", + " 'fsize' : int\n", + " The size of the font.\n", + " 'unit_real_ids' : list of int\n", + " The unit ids from the experimental recording.\n", + " 'lw' : int\n", + " The default line width.\n", + " 'ms' : int\n", + " The marker size for the unitary events and coincidences.\n", + "\n", + " Returns\n", + " -------\n", + " result : FigureUE\n", + " The container for Axes objects generated by the function. Individual\n", + " axes can be accessed using the following identifiers:\n", + "\n", + " * axes_spike_events : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the spike events subplot.\n", + " * axes_spike_rates : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the spike rates subplot.\n", + " * axes_coincident_events : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the coincident events subplot.\n", + " * axes_coincidence_rates : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the coincidence rates subplot.\n", + " * axes_significance : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the statistical significance subplot.\n", + " * axes_unitary_events : matplotlib.axes.Axes\n", + "\n", + " Contains the elements of the unitary events subplot.\n", + "\n", + " Examples\n", + " --------\n", + " Unitary Events of homogenous Poisson random processes.\n", + "\n", + " Since we don't expect to find significant correlations in random processes,\n", + " we show non-significant events (``significance_level=0.34``). Typically,\n", + " in your analyses, the significant level threshold is ~0.05.\n", + "\n", + " .. plot::\n", + " :include-source:\n", + "\n", + " import matplotlib.pyplot as plt\n", + " import numpy as np\n", + " import quantities as pq\n", + "\n", + " import viziphant\n", + " from elephant.spike_train_generation import homogeneous_poisson_process\n", + " from elephant.unitary_event_analysis import jointJ_window_analysis\n", + "\n", + " np.random.seed(10)\n", + "\n", + " spiketrains1 = [homogeneous_poisson_process(rate=20 * pq.Hz,\n", + " t_stop=2 * pq.s) for _ in range(5)]\n", + " spiketrains2 = [homogeneous_poisson_process(rate=50 * pq.Hz,\n", + " t_stop=2 * pq.s) for _ in range(5)]\n", + "\n", + " spiketrains = np.stack((spiketrains1, spiketrains2), axis=1)\n", + " ue_dict = jointJ_window_analysis(spiketrains,\n", + " bin_size=5 * pq.ms,\n", + " win_size=100 * pq.ms,\n", + " win_step=10 * pq.ms)\n", + " viziphant.unitary_event_analysis.plot_ue(spiketrains, Js_dict=ue_dict,\n", + " significance_level=0.34,\n", + " unit_real_ids=['1', '2'])\n", + " plt.show()\n", + "\n", + " Refer to `UEA Tutorial `_ for real-case scenario.\n", " \"\"\"\n", - " import matplotlib.pylab as plt\n", - " t_start = data[0][0].t_start\n", - " t_stop = data[0][0].t_stop\n", + " n_trials = len(spiketrains)\n", + " n_neurons = len(spiketrains[0])\n", "\n", + " input_parameters = Js_dict['input_parameters']\n", + " t_start = input_parameters['t_start']\n", + " t_stop = input_parameters['t_stop']\n", + " bin_size = input_parameters['bin_size']\n", + " win_size = input_parameters['win_size']\n", + " win_step = input_parameters['win_step']\n", + " pattern_hash = input_parameters['pattern_hash']\n", + " if len(pattern_hash) > 1:\n", + " raise ValueError(f\"To not clutter the plots, only one pattern hash is \"\n", + " f\"required; got {pattern_hash}. You can call this \"\n", + " f\"function multiple times for each hash at a time.\")\n", + " for key in ['Js', 'n_emp', 'n_exp', 'rate_avg']:\n", + " Js_dict[key] = Js_dict[key].squeeze()\n", + " neurons_participated = ue.inverse_hash_from_pattern(pattern_hash,\n", + " N=n_neurons).squeeze()\n", "\n", - " arg_dict = {'events':{},'figsize':(12,10), 'top':0.9, 'bottom':0.05, 'right':0.95,'left':0.1,\n", - " 'hspace':0.5,'wspace':0.5,'fontsize':15,'unit_ids':range(1,N+1,1),\n", - " 'ch_real_ids':[],'showfig':False, 'lw':2,'S_ylim':[-3,3],\n", - " 'marker_size':8, 'suptitle':False, 'set_xticks':False,\n", - " 'save_fig':False,'path_filename_format':'UE.pdf'}\n", - " arg_dict.update(kwargs)\n", - " \n", - " num_tr = len(data)\n", - " unit_real_ids = arg_dict['unit_ids']\n", - " \n", - " num_row = 5\n", - " num_col = 1\n", + " t_winpos = ue._winpos(t_start=t_start, t_stop=t_stop, win_size=win_size,\n", + " win_step=win_step)\n", + " Js_sig = ue.jointJ(significance_level)\n", + "\n", + " # figure format\n", + " plot_params_user = plot_params\n", + " plot_params = plot_params_default.copy()\n", + " plot_params.update(plot_params_user)\n", + " if plot_params['unit_real_ids'] is None:\n", + " plot_params['unit_real_ids'] = ['not specified'] * n_neurons\n", + " if len(plot_params['unit_real_ids']) != n_neurons:\n", + " raise ValueError('length of unit_ids should be' +\n", + " 'equal to number of neurons!')\n", + " plt.rcParams.update({'font.size': plot_params['fsize']})\n", " ls = '-'\n", " alpha = 0.5\n", - " plt.figure(1,figsize = arg_dict['figsize'])\n", - " if arg_dict['suptitle'] == True:\n", - " plt.suptitle(\"Spike Pattern:\"+ str((pat.T)[0]),fontsize = 20)\n", - " print('plotting UEs ...')\n", - " plt.subplots_adjust(top=arg_dict['top'], right=arg_dict['right'], left=arg_dict['left']\n", - " , bottom=arg_dict['bottom'], hspace=arg_dict['hspace'] , wspace=arg_dict['wspace'])\n", - " ax = plt.subplot(num_row,1,1)\n", - " ax.set_title('Unitary Events',fontsize = arg_dict['fontsize'],color = 'r')\n", - " for n in range(N):\n", - " for tr,data_tr in enumerate(data):\n", - " plt.plot(data_tr[n].rescale('ms').magnitude, np.ones_like(data_tr[n].magnitude)*tr + n*(num_tr + 1) + 1, '.', markersize=0.5,color = 'k')\n", - " sig_idx_win = np.where(Js_dict['Js']>= Js_sig)[0]\n", - " if len(sig_idx_win)>0:\n", - " x = np.unique(Js_dict['indices']['trial'+str(tr)])\n", - " if len(x)>0:\n", - " xx = []\n", - " for j in sig_idx_win:\n", - " xx =np.append(xx,x[np.where((x*bin_size>=t_winpos[j]) &(x*bin_size= Js_sig)[0]\n", + " t_winpos_significant = t_winpos[mask_nonnan][significant_win_idx]\n", + " axes[5].set_title('Unitary Events')\n", + " if len(t_winpos_significant) > 0:\n", + " for n in range(n_neurons):\n", + " if not neurons_participated[n]:\n", + " continue\n", + " for tr, data_tr in enumerate(spiketrains):\n", + " indices = np.unique(Js_dict['indices'][f'trial{tr}'])\n", + " indices_significant = []\n", + " for t_sig in t_winpos_significant:\n", + " mask = (indices * bin_size >= t_sig\n", + " ) & (indices * bin_size < t_sig + win_size)\n", + " indices_significant.append(indices[mask])\n", + " indices_significant = np.hstack(indices_significant)\n", + " indices_significant = np.unique(indices_significant)\n", + " # does nothing if indices_significant is empty\n", + " axes[5].plot(indices_significant * bin_size,\n", + " np.full_like(indices_significant,\n", + " fill_value=n * n_trials + tr),\n", + " ms=plot_params['ms'], marker='s', ls='',\n", + " mfc='none', mec='r')\n", + " axes[5].set_xlabel(f'Time ({t_winpos.dimensionality})',\n", + " fontsize=plot_params['fsize'])\n", + " for key in plot_params['events'].keys():\n", + " for event_time in plot_params['events'][key]:\n", + " axes[5].text(event_time - 10 * pq.ms,\n", + " axes[5].get_ylim()[0] - 35, key,\n", + " fontsize=plot_params['fsize'], color='r')\n", + "\n", + " plt.suptitle(plot_params['suptitle'], fontsize=20)\n", + " plt.subplots_adjust(top=plot_params['top'],\n", + " right=plot_params['right'],\n", + " left=plot_params['left'],\n", + " bottom=plot_params['bottom'],\n", + " hspace=plot_params['hspace'],\n", + " wspace=plot_params['wspace'])\n", + " \n", + " return axes" ] }, { @@ -302,10 +491,7 @@ "UE = ue.jointJ_window_analysis(\n", " spiketrains, bin_size=5*pq.ms, winsize=100*pq.ms, winstep=10*pq.ms, pattern_hash=[3])\n", "\n", - "plot_UE(\n", - " spiketrains, UE, ue.jointJ(0.05),bin_size=5*pq.ms,winsize=100*pq.ms,winstep=10*pq.ms,\n", - " pat=ue.inverse_hash_from_pattern([3], N=2), N=2,\n", - " t_winpos=ue._winpos(0*pq.ms,spiketrains[0][0].t_stop,winsize=100*pq.ms,winstep=10*pq.ms))\n", + "plot_ue(spiketrains, UE, significance_level=0.05)\n", "plt.show()" ] } @@ -326,7 +512,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.5" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/elephant/test/download.py b/elephant/test/download.py index f6879349c..7efcbac8d 100644 --- a/elephant/test/download.py +++ b/elephant/test/download.py @@ -1,13 +1,12 @@ import hashlib -import os import tempfile +from pathlib import Path +from urllib.request import urlretrieve from zipfile import ZipFile from tqdm import tqdm -from urllib.request import urlretrieve - -ELEPHANT_TMP_DIR = os.path.join(tempfile.gettempdir(), "elephant") +ELEPHANT_TMP_DIR = Path(tempfile.gettempdir()) / "elephant" class TqdmUpTo(tqdm): @@ -31,31 +30,30 @@ def update_to(self, b=1, bsize=1, tsize=None): self.update(b * bsize - self.n) # will also set self.n = b * bsize -def calculate_md5(fpath, chunk_size=1024 * 1024): +def calculate_md5(filepath, chunk_size=1024 * 1024): md5 = hashlib.md5() - with open(fpath, 'rb') as f: + with open(filepath, 'rb') as f: for chunk in iter(lambda: f.read(chunk_size), b''): md5.update(chunk) return md5.hexdigest() -def check_integrity(fpath, md5): - if not os.path.exists(fpath) or md5 is None: +def check_integrity(filepath, md5): + if not Path(filepath).exists() or md5 is None: return False - return calculate_md5(fpath) == md5 + return calculate_md5(filepath) == md5 def download(url, filepath=None, checksum=None, verbose=True): if filepath is None: filename = url.split('/')[-1] - filepath = os.path.join(ELEPHANT_TMP_DIR, filename) + filepath = ELEPHANT_TMP_DIR / filename + filepath = Path(filepath) if check_integrity(filepath, md5=checksum): return filepath - folder = os.path.dirname(os.path.abspath(filepath)) - if not os.path.exists(folder): - os.mkdir(folder) - desc = "Downloading '{url}' to '{filepath}'".format(url=url, - filepath=filepath) + folder = filepath.absolute().parent + folder.mkdir(exist_ok=True) + desc = f"Downloading {url} to '{filepath}'" with TqdmUpTo(unit='B', unit_scale=True, unit_divisor=1024, miniters=1, desc=desc, disable=not verbose) as t: urlretrieve(url, filename=filepath, reporthook=t.update_to) @@ -66,5 +64,4 @@ def unzip(filepath, outdir=ELEPHANT_TMP_DIR, verbose=True): with ZipFile(filepath) as zfile: zfile.extractall(path=outdir) if verbose: - print("Extracted {filepath} to {outdir}".format(filepath=filepath, - outdir=outdir)) + print(f"Extracted {filepath} to {outdir}") diff --git a/elephant/test/test_spike_train_synchrony.py b/elephant/test/test_spike_train_synchrony.py index 13fa4f63f..295f11b83 100644 --- a/elephant/test/test_spike_train_synchrony.py +++ b/elephant/test/test_spike_train_synchrony.py @@ -182,8 +182,8 @@ def test_spike_contrast_with_Izhikevich_network_auto(self): filepath_zip = download(url=izhikevich_url, checksum="70e848500c1d9c6403b66de8c741d849") unzip(filepath_zip) - filepath = filepath_zip.replace(".zip", ".json") - with open(filepath) as read_file: + filepath_json = filepath_zip.with_suffix(".json") + with open(filepath_json) as read_file: data = json.load(read_file) # for the sake of compute time, take the first 5 networks diff --git a/elephant/test/test_unitary_event_analysis.py b/elephant/test/test_unitary_event_analysis.py index e73b6cfe0..9833779d5 100644 --- a/elephant/test/test_unitary_event_analysis.py +++ b/elephant/test/test_unitary_event_analysis.py @@ -5,22 +5,18 @@ :license: Modified BSD, see LICENSE.txt for details. """ -import os -import shutil -import ssl import types import unittest import neo import numpy as np import quantities as pq -from neo.test.rawiotest.tools import create_local_temp_dir from numpy.testing import assert_array_equal -from urllib.request import urlopen - - import elephant.unitary_event_analysis as ue +from elephant.test.download import download, ELEPHANT_TMP_DIR +from numpy.testing import assert_array_almost_equal +from elephant.spike_train_generation import homogeneous_poisson_process class UETestCase(unittest.TestCase): @@ -236,7 +232,8 @@ def test_n_exp_mat_sum_trial_surrogate(self): n_exp_anal = ue.n_exp_mat_sum_trial( mat, pattern_hash, method='analytic_TrialAverage') n_exp_surr = ue.n_exp_mat_sum_trial( - mat, pattern_hash, method='surrogate_TrialByTrial', n_surr=1000) + mat, pattern_hash, method='surrogate_TrialByTrial', + n_surrogates=1000) self.assertLess( a=np.abs(n_exp_anal[0] - np.mean(n_exp_surr)) / n_exp_anal[0], b=0.1) @@ -309,7 +306,7 @@ def test__UE_surrogate(self): mat, pattern_hash, method='surrogate_TrialByTrial', - n_surr=100) + n_surrogates=100) _, rate_avg, _, n_emp, indices =\ ue._UE(mat, pattern_hash, method='analytic_TrialByTrial') self.assertTrue(np.allclose(n_emp, n_emp_surr)) @@ -325,12 +322,15 @@ def test_jointJ_window_analysis(self): sts1 = self.sts1_neo sts2 = self.sts2_neo data = np.vstack((sts1, sts2)).T - winsize = 100 * pq.ms + win_size = 100 * pq.ms bin_size = 5 * pq.ms - winstep = 20 * pq.ms + win_step = 20 * pq.ms pattern_hash = [3] - UE_dic = ue.jointJ_window_analysis( - data, bin_size, winsize, winstep, pattern_hash) + UE_dic = ue.jointJ_window_analysis(spiketrains=data, + pattern_hash=pattern_hash, + bin_size=bin_size, + win_size=win_size, + win_step=win_step) expected_Js = np.array( [0.57953708, 0.47348757, 0.1729669, 0.01883295, -0.21934742, -0.80608759]) @@ -347,16 +347,24 @@ def test_jointJ_window_analysis(self): [0.02388889, 0.02055556]]) * pq.kHz expected_indecis_tril26 = [4., 4.] expected_indecis_tril4 = [1.] - self.assertTrue(np.allclose(UE_dic['Js'], expected_Js)) - self.assertTrue(np.allclose(UE_dic['n_emp'], expected_n_emp)) - self.assertTrue(np.allclose(UE_dic['n_exp'], expected_n_exp)) - self.assertTrue(np.allclose( - UE_dic['rate_avg'].rescale('Hz').magnitude, - expected_rate.rescale('Hz').magnitude)) - self.assertTrue(np.allclose( - UE_dic['indices']['trial26'], expected_indecis_tril26)) - self.assertTrue(np.allclose( - UE_dic['indices']['trial4'], expected_indecis_tril4)) + assert_array_almost_equal(UE_dic['Js'].squeeze(), expected_Js) + assert_array_almost_equal(UE_dic['n_emp'].squeeze(), expected_n_emp) + assert_array_almost_equal(UE_dic['n_exp'].squeeze(), expected_n_exp) + assert_array_almost_equal(UE_dic['rate_avg'].squeeze(), expected_rate) + assert_array_almost_equal(UE_dic['indices']['trial26'], + expected_indecis_tril26) + assert_array_almost_equal(UE_dic['indices']['trial4'], + expected_indecis_tril4) + + # check the input parameters + input_params = UE_dic['input_parameters'] + self.assertEqual(input_params['pattern_hash'], pattern_hash) + self.assertEqual(input_params['bin_size'], bin_size) + self.assertEqual(input_params['win_size'], win_size) + self.assertEqual(input_params['win_step'], win_step) + self.assertEqual(input_params['method'], 'analytic_TrialByTrial') + self.assertEqual(input_params['t_start'], 0 * pq.s) + self.assertEqual(input_params['t_stop'], 200 * pq.ms) @staticmethod def load_gdf2Neo(fname, trigger, t_pre, t_post): @@ -425,20 +433,16 @@ def load_gdf2Neo(fname, trigger, t_pre, t_post): def test_Riehle_et_al_97_UE(self): url = "http://raw.githubusercontent.com/ReScience-Archives/Rostami-" \ "Ito-Denker-Gruen-2017/master/data" - shortname = "unitary_event_analysis_test_data" - local_test_dir = create_local_temp_dir(shortname) - files_to_download = ["extracted_data.npy", "winny131_23.gdf"] - context = ssl._create_unverified_context() - for filename in files_to_download: - url_file = "{url}/{filename}".format(url=url, filename=filename) - dist = urlopen(url_file, context=context) - localfile = os.path.join(local_test_dir, filename) - with open(localfile, 'wb') as f: - f.write(dist.read()) + files_to_download = ( + ("extracted_data.npy", "c4903666ce8a8a31274d6b11238a5ac3"), + ("winny131_23.gdf", "cc2958f7b4fb14dbab71e17bba49bd10") + ) + for filename, checksum in files_to_download: + # The files will be downloaded to ELEPHANT_TMP_DIR + download(url=f"{url}/{filename}", checksum=checksum) # load spike data of figure 2 of Riehle et al 1997 - spiketrain = self.load_gdf2Neo(os.path.join(local_test_dir, - "winny131_23.gdf"), + spiketrain = self.load_gdf2Neo(ELEPHANT_TMP_DIR / "winny131_23.gdf", trigger='RS_4', t_pre=1799 * pq.ms, t_post=300 * pq.ms) @@ -453,13 +457,15 @@ def test_Riehle_et_al_97_UE(self): t_winpos = ue._winpos(t_start, t_stop, winsize, winstep) significance_level = 0.05 - UE = ue.jointJ_window_analysis( - spiketrain, bin_size, winsize, winstep, - pattern_hash, method='analytic_TrialAverage') + UE = ue.jointJ_window_analysis(spiketrain, + pattern_hash=pattern_hash, + bin_size=bin_size, + win_size=winsize, + win_step=winstep, + method='analytic_TrialAverage') # load extracted data from figure 2 of Riehle et al 1997 - extracted_data = np.load( - os.path.join(local_test_dir, 'extracted_data.npy'), - encoding='latin1', allow_pickle=True).item() + extracted_data = np.load(ELEPHANT_TMP_DIR / 'extracted_data.npy', + encoding='latin1', allow_pickle=True).item() Js_sig = ue.jointJ(significance_level) sig_idx_win = np.where(UE['Js'] >= Js_sig)[0] diff_UE_rep = [] @@ -482,15 +488,56 @@ def test_Riehle_et_al_97_UE(self): diff_UE_rep = np.append( diff_UE_rep, x_tmp - ue_trial) y_cnt += +1 - shutil.rmtree(local_test_dir) np.testing.assert_array_less(np.abs(diff_UE_rep), 0.3) - -def suite(): - suite = unittest.makeSuite(UETestCase, 'test') - return suite - - -if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + def test_multiple_neurons(self): + np.random.seed(12) + spiketrains = [[homogeneous_poisson_process( + rate=50 * pq.Hz, t_stop=1 * pq.s) + for _ in range(5)] for neuron in range(3)] + + spiketrains = np.stack(spiketrains, axis=1) + UE_dic = ue.jointJ_window_analysis(spiketrains, bin_size=5 * pq.ms, + win_size=300 * pq.ms, + win_step=100 * pq.ms) + + js_expected = [[0.6081138], [0.17796665], [-1.2601125], + [-0.2790147], [0.07804556], [0.7861176], [0.23452221], + [0.11624397]] + indices_expected = {'trial2': [20, 30, 20, 30, 104, 104, 104], + 'trial3': [21, 21, 65, 65, 65, 128, 128, 128], + 'trial4': [8, 172, 172], + 'trial0': [104, 106, 104, 106, 104, 106], + 'trial1': [158, 158, 158, 188]} + n_emp_expected = [[4.], [4.], [1.], [4.], [4.], [5.], [3.], [3.]] + n_exp_expected = [[2.2858334], [3.2066667], [2.955], [4.485833], + [3.4622223], [2.723611], [2.166111], [2.4122221]] + rate_expected = [[[0.04666667, 0.03266666, 0.04333333]], + [[0.04733333, 0.03666667, 0.044]], + [[0.04533333, 0.03466666, 0.046]], + [[0.04933333, 0.04466667, 0.04933333]], + [[0.04466667, 0.04266667, 0.046]], + [[0.04133333, 0.04466667, 0.044]], + [[0.04133333, 0.03666667, 0.04266667]], + [[0.03933334, 0.03866667, 0.04666667]]] * 1 / pq.ms + input_parameters_expected = {'pattern_hash': [7], + 'bin_size': 5 * pq.ms, + 'win_size': 300 * pq.ms, + 'win_step': 100 * pq.ms, + 'method': 'analytic_TrialByTrial', + 't_start': 0 * pq.s, + 't_stop': 1 * pq.s, 'n_surrogates': 100} + assert_array_almost_equal(UE_dic['Js'], js_expected) + assert_array_almost_equal(UE_dic['n_emp'], n_emp_expected) + assert_array_almost_equal(UE_dic['n_exp'], n_exp_expected) + assert_array_almost_equal(UE_dic['rate_avg'], rate_expected) + self.assertEqual(sorted(UE_dic['indices'].keys()), + sorted(indices_expected.keys())) + for trial_key in indices_expected.keys(): + assert_array_equal(indices_expected[trial_key], + UE_dic['indices'][trial_key]) + self.assertEqual(UE_dic['input_parameters'], input_parameters_expected) + + +if __name__ == '__main__': + unittest.main() diff --git a/elephant/unitary_event_analysis.py b/elephant/unitary_event_analysis.py index 2f0b46557..9b6a49c0b 100644 --- a/elephant/unitary_event_analysis.py +++ b/elephant/unitary_event_analysis.py @@ -54,6 +54,7 @@ from __future__ import division, print_function, unicode_literals import warnings +from collections import defaultdict import neo import numpy as np @@ -61,7 +62,7 @@ import scipy import elephant.conversion as conv -from elephant.utils import is_binary +from elephant.utils import is_binary, deprecated_alias __all__ = [ "hash_from_pattern", @@ -92,7 +93,7 @@ def hash_from_pattern(m, base=2): Rows and columns correspond to patterns and neurons, respectively. base: integer The base for hashes calculation. - Default is 2. + Default: 2 Returns ------- @@ -149,7 +150,7 @@ def inverse_hash_from_pattern(h, N, base=2): The number of neurons. base: integer The base, used to generate the hash values. - Default is 2. + Default: 2 Returns ------- @@ -186,8 +187,8 @@ def inverse_hash_from_pattern(h, N, base=2): # value for N neurons with the given base powers = np.array([base ** x for x in range(N)])[::-1] if any(h > sum(powers)): - raise ValueError( - "hash value is not compatible with the number of neurons N") + raise ValueError(f"hash value {h} is not compatible with the number " + f"of neurons {N}") m = h // np.expand_dims(powers, axis=1) m %= base # m is a binary matrix now m = m.astype(int) # convert object to int if the hash was > int64 @@ -209,7 +210,7 @@ def n_emp_mat(mat, pattern_hash, base=2): of which occurrences are counted. base: integer The base, used to generate the hash values. - Default is 2. + Default: 2 Returns ------- @@ -340,15 +341,15 @@ def _n_exp_mat_analytic(mat, pattern_hash): return np.prod(pmat, axis=0) * float(mat.shape[1]) -def _n_exp_mat_surrogate(mat, pattern_hash, n_surr=1): +def _n_exp_mat_surrogate(mat, pattern_hash, n_surrogates=1): """ Calculates the expected joint probability for each spike pattern with spike time randomization surrogate """ if len(pattern_hash) > 1: raise ValueError('surrogate method works only for one pattern!') - N_exp_array = np.zeros(n_surr) - for rz_idx, rz in enumerate(np.arange(n_surr)): + N_exp_array = np.zeros(n_surrogates) + for rz_idx, rz in enumerate(np.arange(n_surrogates)): # row-wise shuffling all elements of zero-one matrix mat_surr = np.copy(mat) [np.random.shuffle(row) for row in mat_surr] @@ -356,7 +357,7 @@ def _n_exp_mat_surrogate(mat, pattern_hash, n_surr=1): return N_exp_array -def n_exp_mat(mat, pattern_hash, method='analytic', n_surr=1): +def n_exp_mat(mat, pattern_hash, method='analytic', n_surrogates=1): """ Calculates the expected joint probability for each spike pattern. @@ -376,11 +377,11 @@ def n_exp_mat(mat, pattern_hash, method='analytic', n_surr=1): The method with which the expectation is calculated. 'analytic' -- > analytically 'surr' -- > with surrogates (spike time randomization) - Default is 'analytic'. - n_surr: int + Default: 'analytic' + n_surrogates: int number of surrogates for constructing the distribution of expected joint probability. - Default is 1 and this number is needed only when method = 'surr' + Default: 1 and this number is needed only when method = 'surr' Returns ------- @@ -406,7 +407,8 @@ def n_exp_mat(mat, pattern_hash, method='analytic', n_surr=1): >>> n_exp_anal = n_exp_mat(mat, pattern_hash, method='analytic') >>> n_exp_anal [ 0.5 1.5 ] - >>> n_exp_surr = n_exp_mat(mat, pattern_hash, method='surr', n_surr=5000) + >>> n_exp_surr = n_exp_mat(mat, pattern_hash, method='surr', + ... n_surrogates=5000) >>> print(n_exp_surr) [[ 1. 1.] [ 2. 0.] @@ -424,11 +426,12 @@ def n_exp_mat(mat, pattern_hash, method='analytic', n_surr=1): if method == 'analytic': return _n_exp_mat_analytic(mat, pattern_hash) if method == 'surr': - return _n_exp_mat_surrogate(mat, pattern_hash, n_surr=n_surr) + return _n_exp_mat_surrogate(mat, pattern_hash, + n_surrogates=n_surrogates) def n_exp_mat_sum_trial(mat, pattern_hash, method='analytic_TrialByTrial', - n_surr=1): + n_surrogates=1): """ Calculates the expected joint probability for each spike pattern sum over trials. @@ -456,10 +459,10 @@ def n_exp_mat_sum_trial(mat, pattern_hash, method='analytic_TrialByTrial', 'surrogate_TrialByTrial' -- > calculate the distribution of expected coincidences by spike time randomzation in each trial and sum over trials. - Default is 'analytic_trialByTrial'. - n_surr: int, optional + Default: 'analytic_trialByTrial'. + n_surrogates: int, optional The number of surrogate to be used. - Default is 1. + Default: 1 Returns ------- @@ -496,10 +499,10 @@ def n_exp_mat_sum_trial(mat, pattern_hash, method='analytic_TrialByTrial', np.mean(mat, axis=0), pattern_hash, method='analytic') * mat.shape[0] elif method == 'surrogate_TrialByTrial': - n_exp = np.zeros(n_surr) + n_exp = np.zeros(n_surrogates) for mat_tr in mat: n_exp += n_exp_mat(mat_tr, pattern_hash, - method='surr', n_surr=n_surr) + method='surr', n_surrogates=n_surrogates) else: raise ValueError( "The method only works on the zero_one matrix at the moment") @@ -507,7 +510,7 @@ def n_exp_mat_sum_trial(mat, pattern_hash, method='analytic_TrialByTrial', def gen_pval_anal(mat, pattern_hash, method='analytic_TrialByTrial', - n_surr=1): + n_surrogates=1): """ Compute the expected coincidences and a function to calculate the p-value for the given empirical coincidences. @@ -536,11 +539,11 @@ def gen_pval_anal(mat, pattern_hash, method='analytic_TrialByTrial', (analytically) on each trial, then sum over all trials. ''analytic_TrialAverage' -- > calculate the expectency by averaging over trials. - Default is 'analytic_trialByTrial' + Default: 'analytic_trialByTrial' (cf. Gruen et al. 2003) - n_surr: integer, optional + n_surrogates: integer, optional number of surrogate to be used - Default is 1 + Default: 1 Returns -------- @@ -577,7 +580,7 @@ def pval(n_emp): return p elif method == 'surrogate_TrialByTrial': n_exp = n_exp_mat_sum_trial( - mat, pattern_hash, method=method, n_surr=n_surr) + mat, pattern_hash, method=method, n_surrogates=n_surrogates) def pval(n_emp): hist = np.bincount(np.int64(n_exp)) @@ -603,7 +606,7 @@ def jointJ(p_val): Parameters ---------- - p_val: list of float + p_val : float or list of float List of p-values of statistical tests for different pattern. Returns @@ -642,18 +645,19 @@ def _bintime(t, bin_size): Change the real time to `bin_size` units. """ t_dl = t.rescale('ms').magnitude - bin_size_dl = bin_size.rescale('ms').magnitude + bin_size_dl = bin_size.rescale('ms').item() return np.floor(np.array(t_dl) / bin_size_dl).astype(int) -def _winpos(t_start, t_stop, winsize, winstep, position='left-edge'): +@deprecated_alias(winsize='win_size', winstep='win_step') +def _winpos(t_start, t_stop, win_size, win_step, position='left-edge'): """ Calculate the position of the analysis window. """ - t_start_dl = t_start.rescale('ms').magnitude - t_stop_dl = t_stop.rescale('ms').magnitude - winsize_dl = winsize.rescale('ms').magnitude - winstep_dl = winstep.rescale('ms').magnitude + t_start_dl = t_start.rescale('ms').item() + t_stop_dl = t_stop.rescale('ms').item() + winsize_dl = win_size.rescale('ms').item() + winstep_dl = win_step.rescale('ms').item() # left side of the window time if position == 'left-edge': @@ -666,7 +670,7 @@ def _winpos(t_start, t_stop, winsize, winstep, position='left-edge'): return ts_winpos -def _UE(mat, pattern_hash, method='analytic_TrialByTrial', n_surr=1): +def _UE(mat, pattern_hash, method='analytic_TrialByTrial', n_surrogates=1): """ Return the default results of unitary events analysis (Surprise, empirical coincidences and index of where it happened @@ -676,7 +680,7 @@ def _UE(mat, pattern_hash, method='analytic_TrialByTrial', n_surr=1): n_emp, indices = n_emp_mat_sum_trial(mat, pattern_hash) if method == 'surrogate_TrialByTrial': dist_exp, n_exp = gen_pval_anal( - mat, pattern_hash, method, n_surr=n_surr) + mat, pattern_hash, method, n_surrogates=n_surrogates) n_exp = np.mean(n_exp) elif method == 'analytic_TrialByTrial' or \ method == 'analytic_TrialAverage': @@ -686,10 +690,13 @@ def _UE(mat, pattern_hash, method='analytic_TrialByTrial', n_surr=1): return Js, rate_avg, n_exp, n_emp, indices -def jointJ_window_analysis( - data, bin_size, winsize, winstep, pattern_hash, - method='analytic_TrialByTrial', t_start=None, - t_stop=None, binary=True, n_surr=100): +@deprecated_alias(data='spiketrains', binsize='bin_size', winsize='win_size', + winstep='win_step', n_surr='n_surrogates') +def jointJ_window_analysis(spiketrains, bin_size=5 * pq.ms, + win_size=100 * pq.ms, win_step=5 * pq.ms, + pattern_hash=None, method='analytic_TrialByTrial', + t_start=None, t_stop=None, binary=True, + n_surrogates=100): """ Calculates the joint surprise in a sliding window fashion. @@ -697,64 +704,71 @@ def jointJ_window_analysis( Parameters ---------- - data : list + spiketrains : list A list of spike trains (`neo.SpikeTrain` objects) in different trials: - 0-axis --> Trials + * 0-axis --> Trials - 1-axis --> Neurons + * 1-axis --> Neurons - 2-axis --> Spike times - bin_size : pq.Quantity + * 2-axis --> Spike times + bin_size : pq.Quantity, optional The size of bins for discretizing spike trains. - winsize : pq.Quantity + Default: 5 ms + win_size : pq.Quantity, optional The size of the window of analysis. - winstep : pq.Quantity + Default: 100 ms + win_step : pq.Quantity, optional The size of the window step. - pattern_hash : list of int - list of interested patterns in hash values - (see `hash_from_pattern` and `inverse_hash_from_pattern` functions) - method : str - The method with which the unitary events whould be computed - 'analytic_TrialByTrial' -- > calculate the expectency - (analytically) on each trial, then sum over all trials. - - 'analytic_TrialAverage' -- > calculate the expectency - by averaging over trials (cf. Gruen et al. 2003). - - 'surrogate_TrialByTrial' -- > calculate the distribution - of expected coincidences by spike time randomzation in - each trial and sum over trials. - Default is 'analytic_trialByTrial' - t_start : float or pq.Quantity, optional - The start time to use for the time points. - If not specified, retrieved from the `t_start` attribute of - spiketrains. - t_stop : float or pq.Quantity, optional - The start time to use for the time points. - If not specified, retrieved from the `t_stop` attribute of - spiketrains. - n_surr : int, optional + Default: 5 ms + pattern_hash : int or list of int or None, optional + A list of interested patterns in hash values (see `hash_from_pattern` + and `inverse_hash_from_pattern` functions). If None, all neurons + are participated. + Default: None + method : str, optional + The method with which to compute the unitary events: + * 'analytic_TrialByTrial': calculate the analytical expectancy + on each trial, then sum over all trials; + + * 'analytic_TrialAverage': calculate the expectancy by averaging over + trials (cf. Gruen et al. 2003); + + * 'surrogate_TrialByTrial': calculate the distribution of expected + coincidences by spike time randomization in each trial and sum over + trials. + Default: 'analytic_trialByTrial' + t_start, t_stop : float or pq.Quantity, optional + The start and stop times to use for the time points. + If not specified, retrieved from the `t_start` and `t_stop` attributes + of the input spiketrains. + binary : bool, optional + Binarize the binned spike train objects (True) or not. Only the binary + matrices are supported at the moment. + Default: True + n_surrogates : int, optional The number of surrogates to be used. - Default is 100. + Default: 100 Returns ------- dict - The values of each key has the shape of - different pattern hash --> 0-axis + The values of the following keys have the shape of - different window --> 1-axis - Js: list of float + * different window --> 0-axis + * different pattern hash --> 1-axis + + 'Js': list of float JointSurprise of different given patterns within each window. - indices: list of list of int + 'indices': list of list of int A list of indices of pattern within each window. - n_emp: list of int + 'n_emp': list of int The empirical number of each observed pattern. - n_exp: list of float + 'n_exp': list of float The expected number of each pattern. - rate_avg: list of float + 'rate_avg': list of float The average firing rate of each neuron. + Additionally, 'input_parameters' key stores the input parameters. Raises ------ @@ -771,71 +785,74 @@ def jointJ_window_analysis( integer. """ - if not isinstance(data[0][0], neo.SpikeTrain): + if not isinstance(spiketrains[0][0], neo.SpikeTrain): raise ValueError( "structure of the data is not correct: 0-axis should be trials, " "1-axis units and 2-axis neo spike trains") if t_start is None: - t_start = data[0][0].t_start.rescale('ms') + t_start = spiketrains[0][0].t_start if t_stop is None: - t_stop = data[0][0].t_stop.rescale('ms') + t_stop = spiketrains[0][0].t_stop + + n_trials = len(spiketrains) + n_neurons = len(spiketrains[0]) + if pattern_hash is None: + pattern = [1] * n_neurons + pattern_hash = hash_from_pattern(pattern) + if np.issubdtype(type(pattern_hash), np.integer): + pattern_hash = [int(pattern_hash)] # position of all windows (left edges) - t_winpos = _winpos(t_start, t_stop, winsize, winstep, position='left-edge') + t_winpos = _winpos(t_start, t_stop, win_size, win_step, + position='left-edge') t_winpos_bintime = _bintime(t_winpos, bin_size) - winsize_bintime = _bintime(winsize, bin_size) - winstep_bintime = _bintime(winstep, bin_size) - - if winsize_bintime * bin_size != winsize: - warnings.warn("The ratio between the winsize ({winsize}) and the " - "bin_size ({bin_size}) is not an integer".format( - winsize=winsize, - bin_size=bin_size)) - - if winstep_bintime * bin_size != winstep: - warnings.warn("The ratio between the winstep ({winstep}) and the " - "bin_size ({bin_size}) is not an integer".format( - winstep=winstep, - bin_size=bin_size)) - - num_tr, N = np.shape(data)[:2] - - n_bins = int((t_stop - t_start) / bin_size) - - mat_tr_unit_spt = np.zeros((len(data), N, n_bins)) - for tr, sts in enumerate(data): - sts = list(sts) - bs = conv.BinnedSpikeTrain( - sts, t_start=t_start, t_stop=t_stop, bin_size=bin_size) - if binary is True: - mat = bs.to_bool_array() - else: + winsize_bintime = _bintime(win_size, bin_size) + winstep_bintime = _bintime(win_step, bin_size) + + if winsize_bintime * bin_size != win_size: + warnings.warn(f"The ratio between the win_size ({win_size}) and the " + f"bin_size ({bin_size}) is not an integer") + + if winstep_bintime * bin_size != win_step: + warnings.warn(f"The ratio between the win_step ({win_step}) and the " + f"bin_size ({bin_size}) is not an integer") + + input_parameters = dict(pattern_hash=pattern_hash, bin_size=bin_size, + win_size=win_size, win_step=win_step, + method=method, t_start=t_start, t_stop=t_stop, + n_surrogates=n_surrogates) + + n_bins = int(((t_stop - t_start) / bin_size).simplified.item()) + + mat_tr_unit_spt = np.zeros((len(spiketrains), n_neurons, n_bins), + dtype=np.int32) + for trial, sts in enumerate(spiketrains): + bs = conv.BinnedSpikeTrain(list(sts), t_start=t_start, t_stop=t_stop, + bin_size=bin_size) + if not binary: raise NotImplementedError( "The method works only with binary matrices at the moment") - mat_tr_unit_spt[tr] = mat + mat_tr_unit_spt[trial] = bs.to_bool_array() - num_win = len(t_winpos) - Js_win, n_exp_win, n_emp_win = (np.zeros(num_win) for _ in range(3)) - rate_avg = np.zeros((num_win, N)) - indices_win = {} - for i in range(num_tr): - indices_win['trial' + str(i)] = [] + n_windows = len(t_winpos) + n_hashes = len(pattern_hash) + Js_win, n_exp_win, n_emp_win = np.zeros((3, n_windows, n_hashes), + dtype=np.float32) + rate_avg = np.zeros((n_windows, n_hashes, n_neurons), dtype=np.float32) + indices_win = defaultdict(list) for i, win_pos in enumerate(t_winpos_bintime): mat_win = mat_tr_unit_spt[:, :, win_pos:win_pos + winsize_bintime] - if method == 'surrogate_TrialByTrial': - Js_win[i], rate_avg[i], n_exp_win[i], n_emp_win[ - i], indices_lst = _UE( - mat_win, pattern_hash, method, n_surr=n_surr) - else: - Js_win[i], rate_avg[i], n_exp_win[i], n_emp_win[ - i], indices_lst = _UE(mat_win, pattern_hash, method) - for j in range(num_tr): + Js_win[i], rate_avg[i], n_exp_win[i], n_emp_win[ + i], indices_lst = _UE(mat_win, pattern_hash=pattern_hash, + method=method, n_surrogates=n_surrogates) + for j in range(n_trials): if len(indices_lst[j][0]) > 0: - indices_win[ - 'trial' + str(j)] = np.append( - indices_win['trial' + str(j)], indices_lst[j][0] + win_pos) + indices_win[f"trial{j}"].append(indices_lst[j][0] + win_pos) + for key in indices_win.keys(): + indices_win[key] = np.hstack(indices_win[key]) return {'Js': Js_win, 'indices': indices_win, 'n_emp': n_emp_win, - 'n_exp': n_exp_win, 'rate_avg': rate_avg / bin_size} + 'n_exp': n_exp_win, 'rate_avg': rate_avg / bin_size, + 'input_parameters': input_parameters} From ac51ba9e3cbff75188847a055557f5872e88dcac Mon Sep 17 00:00:00 2001 From: dizcza Date: Tue, 12 Jan 2021 16:38:32 +0100 Subject: [PATCH 05/63] fixed the citation, removed todos, pep8 --- doc/bib/elephant.bib | 2 +- elephant/phase_analysis.py | 14 ++++++-------- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/doc/bib/elephant.bib b/doc/bib/elephant.bib index da2202841..32ed60da2 100644 --- a/doc/bib/elephant.bib +++ b/doc/bib/elephant.bib @@ -147,7 +147,7 @@ @article{Vinck2010_51 publisher={Elsevier} } -@article {PMID:22187161, +@article {Vinck2012_33, Title = {Improved measures of phase-coupling between spikes and the Local Field Potential}, Author = {Vinck, Martin and Battaglia, Francesco Paolo and Womelsdorf, Thilo and Pennartz, Cyriel}, DOI = {10.1007/s10827-011-0374-4}, diff --git a/elephant/phase_analysis.py b/elephant/phase_analysis.py index aa8b21d39..c0546254e 100644 --- a/elephant/phase_analysis.py +++ b/elephant/phase_analysis.py @@ -199,8 +199,8 @@ def pairwise_phase_consistency(phases, method='ppc0'): PPC0 is computed according to Eq. 14 and 15 of the cited paper. - An improved version of the PPC (PPC1) :cite: `PMID:22187161` computes angular - difference ony between pairs of spikes within trials. + An improved version of the PPC (PPC1) :cite:`phase-Vinck2012_33` computes + angular difference ony between pairs of spikes within trials. PPC1 is not implemented yet @@ -230,13 +230,11 @@ def pairwise_phase_consistency(phases, method='ppc0'): Pairwise Phase Consistency """ - # Convert inputs to lists - if not isinstance(phases, list): + if isinstance(phases, np.ndarray): phases = [phases] - - # Check if all elements are arrays if not isinstance(phases, (list, tuple)): raise TypeError("Input must be a list of 1D numpy arrays with phases") + for phase_array in phases: if not isinstance(phase_array, np.ndarray): raise TypeError("Each entry of the input list must be an 1D " @@ -260,7 +258,7 @@ def pairwise_phase_consistency(phases, method='ppc0'): # transpose, we get the distance between phases for all possible pairs # of elements in 'phase' dot_prod = np.multiply(p_cos_2d, p_cos_2d.T, dtype=np.float32) + \ - np.multiply(p_sin_2d, p_sin_2d.T, dtype=np.float32) # TODO: agree on using this precision or not + np.multiply(p_sin_2d, p_sin_2d.T, dtype=np.float32) # Now average over all elements in temp_results (the diagonal are 1 # and should not be included) @@ -270,7 +268,7 @@ def pairwise_phase_consistency(phases, method='ppc0'): # Note: each pair i,j is computed twice in dot_prod. do not # multiply by 2. n_trial * n_trials - n_trials = nr of filled elements # in dot_prod - ppc = np.sum(dot_prod) / (n_trials * n_trials - n_trials) # TODO: handle nan's + ppc = np.sum(dot_prod) / (n_trials * n_trials - n_trials) return ppc elif method == 'ppc1': From 0be27f98e9ee3d58d9ff5357af1c9725af96925f Mon Sep 17 00:00:00 2001 From: Aitor Morales-Gregorio <43403140+morales-gregorio@users.noreply.github.com> Date: Tue, 12 Jan 2021 16:50:00 +0100 Subject: [PATCH 06/63] Improve memory efficiency of _create_sparse_matrix in BinnedSpikeTrain class (#395) Co-authored-by: kleinjohann --- elephant/conversion.py | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index b35602acf..1f6ffa8b8 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -1065,11 +1065,23 @@ def _create_sparse_matrix(self, spiketrains): Spike trains to bin. """ + + # The data type for numeric values + data_dtype = np.int32 + if not _check_neo_spiketrain(spiketrains): # a binned numpy array - sparse_matrix = sps.csr_matrix(spiketrains, dtype=np.int32) + sparse_matrix = sps.csr_matrix(spiketrains, dtype=data_dtype) return sparse_matrix + # Get index dtype that can accomodate the largest index + # (this is the same dtype that will be used for the index arrays of the + # sparse matrix, so already using it here avoids array duplication) + shape = (len(spiketrains), self.n_bins) + numtype = np.int32 + if max(shape) > np.iinfo(numtype).max: + numtype = np.int64 + row_ids, column_ids = [], [] # data counts = [] @@ -1089,21 +1101,29 @@ def _create_sparse_matrix(self, spiketrains): valid_bins = bins[bins < self.n_bins] n_discarded += len(bins) - len(valid_bins) f, c = np.unique(valid_bins, return_counts=True) + # f inherits the dtype np.int32 from bins, but c is created in + # np.unique with the default int dtype (usually np.int64) + c = c.astype(data_dtype) column_ids.append(f) counts.append(c) - row_ids.append(np.repeat(idx, repeats=len(f))) + row_ids.append(np.repeat(idx, repeats=len(f)).astype(numtype)) if n_discarded > 0: warnings.warn("Binning discarded {} last spike(s) of the " "input spiketrain".format(n_discarded)) + # Stacking preserves the data type. In any case, while creating + # the sparse matrix, a copy is performed even if we set 'copy' to False + # explicitly (however, this might change in future scipy versions - + # this depends on scipy csr matrix initialization implementation). counts = np.hstack(counts) - row_ids = np.hstack(row_ids) column_ids = np.hstack(column_ids) + row_ids = np.hstack(row_ids) sparse_matrix = sps.csr_matrix((counts, (row_ids, column_ids)), - shape=(len(spiketrains), self.n_bins), - dtype=np.int32, copy=False) + shape=shape, dtype=data_dtype, + copy=False) + return sparse_matrix From 4a72095d80aae368fb2782d56babcc445462d07e Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Thu, 21 Jan 2021 17:07:03 +0100 Subject: [PATCH 07/63] Joint-ISI dithering: fixed a bug regarding first ISI bin (#396) * fixing boundaries of joint-isi * possible fix of the first-bin-error * changed values of padding --- elephant/spike_train_surrogates.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index 788d3cf75..db0175729 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -1004,7 +1004,7 @@ def _determine_cumulative_functions(self): diagonal = np.diagonal( rotated_jisih, offset=-self.n_bins + double_index + 1) jisih_cum = self._normalize_cumulative_distribution( - np.cumsum(diagonal)) + np.r_[0., np.cumsum(diagonal)]) self._jisih_cumulatives.append(jisih_cum) self._jisih_cumulatives = np.array( self._jisih_cumulatives, dtype=object) @@ -1039,19 +1039,21 @@ def _window_diagonal_cumulatives(self, rotated_jisih): # double_index corresponds to the sum of the indices for the previous # and the subsequent ISI. for double_index in range(self.n_bins): - cum_diag = np.cumsum(np.diagonal(rotated_jisih, - - self.n_bins - + double_index + 1)) + anti_diagonal = np.diagonal( + rotated_jisih, - self.n_bins + double_index + 1) right_padding = jisih_diag_cums.shape[1] - \ - len(cum_diag) - self._max_change_index + len(anti_diagonal) - self._max_change_index - jisih_diag_cums[double_index] = np.pad( - cum_diag, + cumulated_diagonal = np.cumsum(anti_diagonal) + + padded_cumulated_diagonal = np.pad( + cumulated_diagonal, pad_width=(self._max_change_index, right_padding), mode='constant', - constant_values=(cum_diag[0], cum_diag[-1]) - ) + constant_values=(0., cumulated_diagonal[-1])) + + jisih_diag_cums[double_index] = padded_cumulated_diagonal return jisih_diag_cums @@ -1089,7 +1091,7 @@ def _get_dithering_step(self, if self.method == 'fast': cum_dist_func = self._jisih_cumulatives[ double_index] - compare_isi = self._index_to_isi(curr_isi_id) + compare_isi = self._index_to_isi(curr_isi_id + 1) else: cum_dist_func = self._jisih_cumulatives[ curr_isi_id][next_isi_id] @@ -1099,7 +1101,8 @@ def _get_dithering_step(self, # when the method is 'fast', new_isi_id is where the current # ISI id should go to. new_isi_id = np.searchsorted(cum_dist_func, random.random()) - step = self._index_to_isi(new_isi_id) - compare_isi + step = self._index_to_isi(new_isi_id)\ + - compare_isi return step return self._uniform_dither_not_jisi_movable_spikes( From 1e5e33ca3e9916e3c20a288479bec3ed9a9cca04 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Fri, 29 Jan 2021 16:41:07 +0100 Subject: [PATCH 08/63] CUDA accelerated ASSET (#351) --- .gitignore | 1 + doc/reference/asset.rst | 2 +- elephant/asset/__init__.py | 5 + elephant/{ => asset}/asset.py | 520 +++++++++++++++------------ elephant/asset/asset.template.cu | 404 +++++++++++++++++++++ elephant/test/test_asset.py | 70 +++- elephant/utils.py | 39 ++ requirements/requirements-extras.txt | 1 + 8 files changed, 803 insertions(+), 239 deletions(-) create mode 100644 elephant/asset/__init__.py rename elephant/{ => asset}/asset.py (83%) create mode 100644 elephant/asset/asset.template.cu diff --git a/.gitignore b/.gitignore index f69634511..5716c5191 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ nosetests.xml venv/ env/ .pytest_cache/ +**/*/__pycache__ # Compiled source # ################### diff --git a/doc/reference/asset.rst b/doc/reference/asset.rst index f38ef038e..59204c9d2 100644 --- a/doc/reference/asset.rst +++ b/doc/reference/asset.rst @@ -2,7 +2,7 @@ Analysis of Sequences of Synchronous EvenTs (ASSET) =================================================== -.. automodule:: elephant.asset +.. automodule:: elephant.asset.asset References diff --git a/elephant/asset/__init__.py b/elephant/asset/__init__.py new file mode 100644 index 000000000..14cc942b2 --- /dev/null +++ b/elephant/asset/__init__.py @@ -0,0 +1,5 @@ +try: + from .asset import * +except ImportError: + # requirements-extras are missing + pass diff --git a/elephant/asset.py b/elephant/asset/asset.py similarity index 83% rename from elephant/asset.py rename to elephant/asset/asset.py index 6fb5adf66..5dea91f6a 100644 --- a/elephant/asset.py +++ b/elephant/asset/asset.py @@ -99,6 +99,10 @@ """ from __future__ import division, print_function, unicode_literals +import os +import subprocess +import sys +import tempfile import warnings import neo @@ -111,6 +115,7 @@ import elephant.conversion as conv from elephant import spike_train_surrogates +from elephant.utils import get_cuda_capability_major try: from mpi4py import MPI @@ -136,6 +141,20 @@ "synchronous_events_overlap" ] + +def _is_cuda_available(): + # a silly way to check for CUDA support + # experimental: should not be public API + try: + subprocess.run(["nvcc", "-V"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE).check_returncode() + available = True + except (OSError, subprocess.CalledProcessError): + available = False + return available + + # ============================================================================= # Some Utility Functions to be dealt with in some way or another # ============================================================================= @@ -410,224 +429,247 @@ def _interpolate_signals(signals, sampling_times, verbose=False): return interpolated_signal -def _num_iterations(n, d): - if d > n: - return 0 - if d == 1: - return n - if d == 2: - # equivalent to np.sum(count_matrix) - return n * (n + 1) // 2 - 1 - - # Create square matrix with diagonal values equal to 2 to `n`. - # Start from row/column with index == 2 to facilitate indexing. - count_matrix = np.zeros((n + 1, n + 1), dtype=int) - np.fill_diagonal(count_matrix, np.arange(n + 1)) - count_matrix[1, 1] = 0 - - # Accumulate counts of all the iterations where the first index - # is in the interval `d` to `n`. - # - # The counts for every level is obtained by accumulating the - # `count_matrix`, which is the count of iterations with the first - # index between `d` and `n`, when `d` == 2. - # - # For every value from 3 to `d`... - # 1. Define each row `n` in the count matrix as the sum of all rows - # equal or above. - # 2. Set all rows above the current value of `d` with zeros. - # - # Example for `n` = 6 and `d` = 4: - # - # d = 2 (start) d = 3 - # count count - # n n - # 2 2 0 0 0 0 - # 3 0 3 0 0 0 ==> 3 2 3 0 0 0 ==> - # 4 0 0 4 0 0 4 2 3 4 0 0 - # 5 0 0 0 5 0 5 2 3 4 5 0 - # 6 0 0 0 0 6 6 2 3 4 5 6 - # - # d = 4 - # count - # n - # - # 4 4 6 4 0 0 - # 5 6 9 8 5 0 - # 6 8 12 12 10 6 - # - # The total number is the sum of the `count_matrix` when `d` has - # the value passed to the function. - # - - for cur_d in range(3, d + 1): - for cur_n in range(n, 2, -1): - count_matrix[cur_n, :] = np.sum(count_matrix[:cur_n + 1, :], - axis=0) - # Set previous `d` level to zeros - count_matrix[cur_d - 1, :] = 0 - return np.sum(count_matrix) - - -def _combinations_with_replacement(n, d): - # Generate sequences of {a_i} such that - # a_0 >= a_1 >= ... >= a_(d-1) and - # d-i <= a_i <= n, for each i in [0, d-1]. - # - # Almost equivalent to - # list(itertools.combinations_with_replacement(range(n, 0, -1), r=d))[::-1] - # - # Example: - # _combinations_with_replacement(n=13, d=3) --> - # (3, 2, 1), (3, 2, 2), (3, 3, 1), ... , (13, 13, 12), (13, 13, 13). - # - # The implementation follows the insertion sort algorithm: - # insert a new element a_i from right to left to keep the reverse sorted - # order. Now substitute increment operation for insert. - if d > n: - return - if d == 1: - for matrix_entry in range(1, n + 1): - yield (matrix_entry,) - return - sequence_sorted = list(range(d, 0, -1)) - input_order = tuple(sequence_sorted) # fixed - while sequence_sorted[0] != n + 1: - for last_element in range(1, sequence_sorted[-2] + 1): - sequence_sorted[-1] = last_element - yield tuple(sequence_sorted) - increment_id = d - 2 - while increment_id > 0 and sequence_sorted[increment_id - 1] == \ - sequence_sorted[increment_id]: - increment_id -= 1 - sequence_sorted[increment_id + 1:] = input_order[increment_id + 1:] - sequence_sorted[increment_id] += 1 - - -def _jsf_uniform_orderstat_3d(u, n, verbose=False): - r""" - Considered n independent random variables X1, X2, ..., Xn all having - uniform distribution in the interval (0, 1): +class _JSFUniformOrderStat3D(object): + def __init__(self, n, d, precision='double', verbose=False, + cuda_threads=64, cuda_cwr_loops=32): + if d > n: + raise ValueError("d ({d}) must be less or equal n ({n})".format( + d=d, n=n)) + self.n = n + self.d = d + self.precision = precision + self.verbose = verbose and rank == 0 + self.cuda_threads = cuda_threads + self.cuda_cwr_loops = cuda_cwr_loops + self.map_iterations = self._create_iteration_table() - .. centered:: Xi ~ Uniform(0, 1), + @property + def num_iterations(self): + # map_iterations table is populated with element indices, not counts; + # therefore, we add 1 + return self.map_iterations[:, -1].sum() + 1 + + def _create_iteration_table(self): + # do not use numpy arrays - they are limited to uint64 + map_iterations = [list(range(self.n))] + for row_id in range(1, self.d): + prev_row = map_iterations[row_id - 1] + curr_row = [0] * (row_id + 1) + for col_id in range(row_id + 1, self.n): + cumsum = prev_row[col_id] + curr_row[-1] + curr_row.append(cumsum) + map_iterations.append(curr_row) + # here we can wrap the resulting array in numpy: + # if at least one item is greater than 2<<63 - 1, + # the data type will be set to 'object' + map_iterations = np.vstack(map_iterations) + return map_iterations + + def _next_sequence_sorted(self, iteration): + # an alternative implementation to naive for-loop iteration when the + # MPI size is large. However, it's not clear under which circumstances, + # if any, there is a benefit. That's why this function is not used. + sequence_sorted = [] + element = self.n - 1 + for row in range(self.d - 1, -1, -1): + map_row = self.map_iterations[row] + while element > row and iteration < map_row[element]: + element -= 1 + iteration -= map_row[element] + sequence_sorted.append(element + 1) + return tuple(sequence_sorted) + + def _combinations_with_replacement(self): + # Generate sequences of {a_i} such that + # a_0 >= a_1 >= ... >= a_(d-1) and + # d-i <= a_i <= n, for each i in [0, d-1]. + # + # Almost equivalent to + # list(itertools.combinations_with_replacement(range(n, 0, -1), r=d)) + # [::-1] + # + # Example: + # _combinations_with_replacement(n=13, d=3) --> + # (3, 2, 1), (3, 2, 2), (3, 3, 1), ... , (13, 13, 12), (13, 13, 13). + # + # The implementation follows the insertion sort algorithm: + # insert a new element a_i from right to left to keep the reverse + # sorted order. Now substitute increment operation for insert. + if self.d > self.n: + return + if self.d == 1: + for matrix_entry in range(1, self.n + 1): + yield (matrix_entry,) + return + sequence_sorted = list(range(self.d, 0, -1)) + input_order = tuple(sequence_sorted) # fixed + while sequence_sorted[0] != self.n + 1: + for last_element in range(1, sequence_sorted[-2] + 1): + sequence_sorted[-1] = last_element + yield tuple(sequence_sorted) + increment_id = self.d - 2 + while increment_id > 0 and sequence_sorted[increment_id - 1] == \ + sequence_sorted[increment_id]: + increment_id -= 1 + sequence_sorted[increment_id + 1:] = input_order[increment_id + 1:] + sequence_sorted[increment_id] += 1 + + def cpu(self, log_du): + log_1 = np.log(1.) + # Compute the log of the integral's coefficient + logK = np.sum(np.log(np.arange(1, self.n + 1))) + # Add to the 3D matrix u a bottom layer equal to 0 and a + # top layer equal to 1. Then compute the difference du along + # the first dimension. + + # prepare arrays for usage inside the loop + di_scratch = np.empty_like(log_du, dtype=np.int32) + log_du_scratch = np.empty_like(log_du) + + # precompute log(factorial)s + # pad with a zero to get 0! = 1 + log_factorial = np.hstack((0, np.cumsum(np.log(range(1, self.n + 1))))) + + # compute the probabilities for each unique row of du + # only loop over the indices and do all du entries at once + # using matrix algebra + # initialise probabilities to 0 + P_total = np.zeros( + log_du.shape[0], + dtype=np.float32 if self.precision == 'float' else np.float64 + ) + + for iter_id, matrix_entries in enumerate( + tqdm(self._combinations_with_replacement(), + total=self.num_iterations, + desc="Joint survival function", + disable=not self.verbose)): + # if we are running with MPI + if mpi_accelerated and iter_id % size != rank: + continue + # we only need the differences of the indices: + di = -np.diff((self.n,) + matrix_entries + (0,)) - given a 2D matrix U = (u_ij) where each U_i is an array of length d: - U_i = [u0, u1, ..., u_{d-1}] of quantiles, with u1 <= u2 <= ... <= un, - computes the joint survival function (jsf) of the d highest order - statistics (U_{n-d+1}, U_{n-d+2}, ..., U_n), - where U_k := "k-th highest X's" at each u_i, i.e.: + # reshape the matrix to be compatible with du + di_scratch[:, range(len(di))] = di - .. centered:: jsf(u_i) = Prob(U_{n-k} >= u_ijk, k=0,1,..., d-1). + # use precomputed factorials + sum_log_di_factorial = log_factorial[di].sum() - Parameters - ---------- - u : (A,d) np.ndarray - 2D matrix of floats between 0 and 1. - Each row `u_i` is an array of length `d`, considered a set of - `d` largest order statistics extracted from a sample of `n` random - variables whose cdf is `F(x) = x` for each `x`. - The routine computes the joint cumulative probability of the `d` - values in `u_ij`, for each `i` and `j`. - n : int - Size of the sample where the `d` largest order statistics `u_ij` are - assumed to have been sampled from. - verbose : bool - If True, print messages during the computation. - Default: False. + # Compute for each i,j the contribution to the probability + # given by this step, and add it to the total probability - Returns - ------- - P_total : (A,) np.ndarray - Matrix of joint survival probabilities. `s_ij` is the joint survival - probability of the values `{u_ijk, k=0, ..., d-1}`. - Note: the joint probability matrix computed for the ASSET analysis - is `1 - S`. - """ - num_p_vals, d = u.shape - - # Define ranges [1,...,n], [2,...,n], ..., [d,...,n] for the mute variables - # used to compute the integral as a sum over all possibilities - it_todo = _num_iterations(n, d) - - log_1 = np.log(1.) - # Compute the log of the integral's coefficient - logK = np.sum(np.log(np.arange(1, n + 1))) - # Add to the 3D matrix u a bottom layer equal to 0 and a - # top layer equal to 1. Then compute the difference du along - # the first dimension. - du = np.diff(u, prepend=0, append=1, axis=1) - - # precompute logarithms - # ignore warnings about infinities, see inside the loop: - # we replace 0 * ln(0) by 1 to get exp(0 * ln(0)) = 0 ** 0 = 1 - # the remaining infinities correctly evaluate to - # exp(ln(0)) = exp(-inf) = 0 - with warnings.catch_warnings(): - warnings.simplefilter('ignore', RuntimeWarning) - log_du = np.log(du) - - # prepare arrays for usage inside the loop - di_scratch = np.empty_like(du, dtype=np.int32) - log_du_scratch = np.empty_like(log_du) - - # precompute log(factorial)s - # pad with a zero to get 0! = 1 - log_factorial = np.hstack((0, np.cumsum(np.log(range(1, n + 1))))) - - # compute the probabilities for each unique row of du - # only loop over the indices and do all du entries at once - # using matrix algebra - # initialise probabilities to 0 - P_total = np.zeros(du.shape[0], dtype=np.float32) - for iter_id, matrix_entries in enumerate( - tqdm(_combinations_with_replacement(n, d=d), - total=it_todo, - desc="Joint survival function", - disable=not verbose)): - # if we are running with MPI - if mpi_accelerated and iter_id % size != rank: - continue - - # we only need the differences of the indices: - di = -np.diff((n,) + matrix_entries + (0,)) - - # reshape the matrix to be compatible with du - di_scratch[:, range(len(di))] = di - - # use precomputed factorials - sum_log_di_factorial = log_factorial[di].sum() - - # Compute for each i,j the contribution to the probability - # given by this step, and add it to the total probability - - # Use precomputed log - np.copyto(log_du_scratch, log_du) - - # for each a=0,1,...,A-1 and b=0,1,...,B-1, replace du with 1 - # whenever di_scratch = 0, so that du ** di_scratch = 1 (this avoids - # nans when both du and di_scratch are 0, and is mathematically - # correct) - log_du_scratch[di_scratch == 0] = log_1 - - di_log_du = di_scratch * log_du_scratch - sum_di_log_du = di_log_du.sum(axis=1) - logP = sum_di_log_du - sum_log_di_factorial - - P_total += np.exp(logP + logK) - - if mpi_accelerated: - totals = np.zeros(du.shape[0], dtype=np.float32) - - # exchange all the results - comm.Allreduce( - [P_total, MPI.FLOAT], - [totals, MPI.FLOAT], - op=MPI.SUM) - - # We need to return the collected totals instead of the local P_total - return totals - - return P_total + # Use precomputed log + np.copyto(log_du_scratch, log_du) + + # for each a=0,1,...,A-1 and b=0,1,...,B-1, replace du with 1 + # whenever di_scratch = 0, so that du ** di_scratch = 1 (this + # avoids nans when both du and di_scratch are 0, and is + # mathematically correct) + log_du_scratch[di_scratch == 0] = log_1 + + di_log_du = di_scratch * log_du_scratch + sum_di_log_du = di_log_du.sum(axis=1) + logP = sum_di_log_du - sum_log_di_factorial + + P_total += np.exp(logP + logK) + + if mpi_accelerated: + totals = np.zeros_like(P_total) + + # exchange all the results + mpi_float_type = MPI.FLOAT \ + if self.precision == 'float' else MPI.DOUBLE + comm.Allreduce( + [P_total, mpi_float_type], + [totals, mpi_float_type], + op=MPI.SUM) + + # We need to return the collected totals instead of the local + # P_total + P_total = totals + + return P_total + + def _compile_cuda_template(self, u_length): + from jinja2 import Template + cu_template_path = os.path.join( + os.path.dirname(os.path.abspath(__file__)), "asset.template.cu") + with open(cu_template_path) as f: + cu_template = Template(f.read()) + asset_cu = cu_template.render( + ASSET_DEBUG=int(self.verbose), + precision=self.precision, + N_THREADS=self.cuda_threads, + CWR_LOOPS=self.cuda_cwr_loops, + L=u_length, N=self.n, D=self.d) + return asset_cu + + def cuda(self, log_du): + asset_cu = self._compile_cuda_template(u_length=log_du.shape[0]) + with tempfile.TemporaryDirectory() as asset_tmp_folder: + asset_cu_path = os.path.join(asset_tmp_folder, 'asset.cu') + asset_bin_path = os.path.join(asset_tmp_folder, 'asset.o') + with open(asset_cu_path, 'w') as f: + f.write(asset_cu) + # -O3 optimization flag is for the host code only; + # by default, GPU device code is optimized with -O3 + compile_cmd = ['nvcc', '-O3', '-o', asset_bin_path, asset_cu_path] + if self.precision == 'double' and get_cuda_capability_major() >= 6: + # atomicAdd(double) requires compute capability 6.x + compile_cmd.extend(['-arch', 'sm_60']) + compile_status = subprocess.run( + compile_cmd, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + compile_status.check_returncode() + log_du_path = os.path.join(asset_tmp_folder, "log_du.txt") + P_total_path = os.path.join(asset_tmp_folder, "P_total.txt") + np.savetxt(log_du_path, log_du, fmt="%.10f") + run_status = subprocess.run( + [asset_bin_path, log_du_path, P_total_path], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + if self.verbose: + print(run_status.stdout.decode()) + print(run_status.stderr.decode(), file=sys.stderr) + run_status.check_returncode() + P_total = np.genfromtxt(P_total_path) + + # Large number of floating-point additions can result in values + # outside of the valid range [0, 1]. + P_total = np.clip(P_total, a_min=0., a_max=1.) + + return P_total + + def _choose_backend(self): + if int(os.getenv("ELEPHANT_USE_CUDA", '1')) == 0: + # don't use CUDA + return self.cpu + if not _is_cuda_available(): + return self.cpu + if self.d < 3 or self.n <= 10: + return self.cpu + return self.cuda + + def compute(self, u): + if u.shape[1] != self.d: + raise ValueError("Invalid input data shape axis 1: expected {}, " + "got {}".format(self.d, u.shape[1])) + du = np.diff(u, prepend=0, append=1, axis=1) + + # precompute logarithms + # ignore warnings about infinities, see inside the loop: + # we replace 0 * ln(0) by 1 to get exp(0 * ln(0)) = 0 ** 0 = 1 + # the remaining infinities correctly evaluate to + # exp(ln(0)) = exp(-inf) = 0 + with warnings.catch_warnings(): + warnings.simplefilter('ignore', RuntimeWarning) + log_du = np.log(du) + + jsf_backend = self._choose_backend() + + P_total = jsf_backend(log_du) + + return P_total def _pmat_neighbors(mat, filter_shape, n_largest): @@ -964,12 +1006,11 @@ def synchronous_events_no_overlap(sse1, sse2): return False common_pixels = set(sse11.keys()).intersection(set(sse22.keys())) - if common_pixels == set([]): + if len(common_pixels) == 0: return True - elif all(sse11[p].isdisjoint(sse22[p]) for p in common_pixels): + if all(sse11[p].isdisjoint(sse22[p]) for p in common_pixels): return True - else: - return False + return False def synchronous_events_contained_in(sse1, sse2): @@ -1020,7 +1061,7 @@ def synchronous_events_contained_in(sse1, sse2): for pixel1, link1 in sse11.items(): if pixel1 not in sse22.keys(): return False - elif not link1.issubset(sse22[pixel1]): + if not link1.issubset(sse22[pixel1]): return False # Check that sse1 is a STRICT subset of sse2, i.e. that sse2 contains at @@ -1226,7 +1267,7 @@ def __init__(self, spiketrains_i, spiketrains_j=None, bin_size=3 * pq.ms, spiketrains_j, t_start=t_start_j, t_stop=t_stop_j) - self.verbose = verbose + self.verbose = verbose and rank == 0 msg = 'The time intervals for x and y need to be either identical ' \ 'or fully disjoint, but they are:\n' \ @@ -1604,7 +1645,8 @@ def probability_matrix_analytical(self, imat=None, return pmat def joint_probability_matrix(self, pmat, filter_shape, n_largest, - min_p_value=1e-5): + min_p_value=1e-5, precision='double', + cuda_threads=64, cuda_cwr_loops=32): """ Map a probability matrix `pmat` to a joint probability matrix `jmat`, where `jmat[i, j]` is the joint p-value of the largest neighbors of @@ -1636,13 +1678,41 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, `min(pmat[i, j], 1-p_value_min)` to avoid that a single highly significant value in `pmat` (extreme case: `pmat[i, j] = 1`) yields joint significance of itself and its neighbors. - Default: 1e-5. + Default: 1e-5 + precision : {'float', 'double'}, optional + The floating-point precision of the resulting `jmat` matrix. + * `'float'`: 32 bits; the tolerance error is ``≲1e-3``. + + * `'double'`: 64 bits; the tolerance error is ``<1e-5``. + Default: 'float' + cuda_threads : int, optional + The number of CUDA threads per block (in X axis) between 1 and + 1024 and is used only if CUDA backend is enabled. + For performance reasons, it should be a multiple of 32. + Old GPUs (Tesla K80) perform faster with `cuda_threads` larger + than 64 while new series (Tesla T4) with capabilities 6.x and more + work best with 32 threads. + Default: 64 + cuda_cwr_loops : int, optional + CUDA optimization parameter, a positive integer that defines the + number of fast 'combinations_with_replacement' loops to run to + reduce branch divergence. This parameter influences the performance + when the number of iterations is huge (`>1e8`). + Default: 32 Returns ------- jmat : np.ndarray The joint probability matrix associated to `pmat`. + Notes + ----- + By default, if a GPU is detected, CUDA implementations is used for + large arrays. To turn off CUDA features, set the environment flag + `ELEPHANT_USE_CUDA=0` either in python or via the command line: + + ``ELEPHANT_USE_CUDA=0 python /path/to/script`` + """ l, w = filter_shape @@ -1664,8 +1734,12 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, # Compute the joint p-value matrix jpvmat n = l * (1 + 2 * w) - w * ( w + 1) # number of entries covered by kernel - jpvmat = _jsf_uniform_orderstat_3d(pmat_neighb, n, - verbose=self.verbose) + jsf = _JSFUniformOrderStat3D(n=n, d=pmat_neighb.shape[1], + precision=precision, + verbose=self.verbose, + cuda_threads=cuda_threads, + cuda_cwr_loops=cuda_cwr_loops) + jpvmat = jsf.compute(u=pmat_neighb) # restore the original shape using the stored indices jpvmat = jpvmat[pmat_neighb_indices].reshape(pmat.shape) diff --git a/elephant/asset/asset.template.cu b/elephant/asset/asset.template.cu new file mode 100644 index 000000000..c33926675 --- /dev/null +++ b/elephant/asset/asset.template.cu @@ -0,0 +1,404 @@ +/** + * CUDA implementation of ASSET.joint_probability_matrix function (refer to + * Python documentation). + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +#define L {{L}} +#define N {{N}} +#define D {{D}} + +#define min_macros(a,b) (a < b ? a : b) + +#define ASSET_DEBUG {{ASSET_DEBUG}} +#define ULL unsigned long long + + +/** + * The maximum number of threads per block. + * This number must be in range [1, 1024]. + * The effective number of threads will be set dynamically + * at runtime to match the tile (width L) of a block. + */ +#define N_THREADS {{N_THREADS}} + +/** + * To reduce branch divergence in 'next_sequence_sorted' function + * within a warp (threads in a warp take different branches), + * each thread runs CWR_LOOPS of 'combinations_with_replacement'. + */ +#define CWR_LOOPS {{CWR_LOOPS}} + +#define L_BLOCK_SUPREMUM min_macros(N_THREADS, L) + +typedef {{precision}} asset_float; + +__constant__ asset_float log_factorial[N + 1]; +__constant__ asset_float logK; +__constant__ ULL ITERATIONS_TODO; +__constant__ unsigned int L_BLOCK; +__constant__ ULL L_NUM_BLOCKS; +__constant__ ULL iteration_table[D][N]; /* Maps the iteration ID to the entries + of a sequence_sorted array */ + +/** + * Compute capabilities lower than 6.0 don't have hardware support for + * double-precision atomicAdd. This software implementation is taken from + * https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html + */ +#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 600 +__device__ double atomicAdd(double* address, double val) +{ + ULL* address_as_ull = (ULL*)address; + ULL old = *address_as_ull, assumed; + + do { + assumed = old; + old = atomicCAS(address_as_ull, assumed, + __double_as_longlong(val + + __longlong_as_double(assumed))); + + // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN) + } while (assumed != old); + + return __longlong_as_double(old); +} +#endif + + +/** + * Builds the next sequence_sorted, given the absolute iteration ID. + * The time complexity is O(N+D), not O(N*D). + * + * @param sequence_sorted the output sequence_sorted array of size D + * @param iteration the global iteration ID + */ +__device__ void next_sequence_sorted(int *sequence_sorted, ULL iteration) { + int row, element = N - 1; + for (row = D - 1; row >= 0; row--) { + while (element > row && iteration < iteration_table[row][element]) { + element--; + } + iteration -= iteration_table[row][element]; + sequence_sorted[D - 1 - row] = element + 1; + } +} + + +/** + * Set 'sequence_sorted' to the next valid sequence of indices in-place. + */ +__device__ void combinations_with_replacement(int *sequence_sorted) { + int increment_id = D - 1; + while (increment_id > 0 && sequence_sorted[increment_id - 1] == sequence_sorted[increment_id]) { + sequence_sorted[increment_id] = D - increment_id; + increment_id--; + } + sequence_sorted[increment_id]++; +} + + +/** + * CUDA kernel that computes P_total - the joint survival probabilities matrix. + * + * @param P_out P_total output array of size L + * @param log_du_device input log_du flattened matrix of size L*(D+1) + */ +__global__ void jsf_uniform_orderstat_3d_kernel(asset_float *P_out, float *log_du_device) { + unsigned int i, row; + + // the row shift of log_du and P_total in the number of elements, between 0 and L + const unsigned int l_shift = (blockIdx.x % L_NUM_BLOCKS) * L_BLOCK; + + // account for the last block width that can be less than L_BLOCK + const unsigned int block_width = (L - l_shift < L_BLOCK) ? (L - l_shift) : L_BLOCK; + + extern __shared__ float shared_mem[]; + asset_float *P_total = (asset_float*) shared_mem; // L_BLOCK floats + float *log_du = (float*)&P_total[L_BLOCK]; // L_BLOCK * (D + 1) floats + + for (row = threadIdx.x; row < block_width; row += blockDim.x) { + P_total[row] = 0; + for (i = 0; i <= D; i++) { + log_du[row * (D + 1) + i] = log_du_device[(row + l_shift) * (D + 1) + i]; + } + } + + __syncthreads(); + + int di[D + 1]; + int sequence_sorted[D]; + asset_float P_thread[L_BLOCK_SUPREMUM]; + for (row = 0; row < block_width; row++) { + P_thread[row] = 0; + } + + const ULL burnout = (blockIdx.x / L_NUM_BLOCKS) * blockDim.x * CWR_LOOPS + threadIdx.x * CWR_LOOPS; + const ULL stride = (gridDim.x / L_NUM_BLOCKS) * blockDim.x * CWR_LOOPS; + + ULL iteration, cwr_loop; + for (iteration = burnout; iteration < ITERATIONS_TODO; iteration += stride) { + next_sequence_sorted(sequence_sorted, iteration); + + for (cwr_loop = 0; (cwr_loop < CWR_LOOPS) && (sequence_sorted[0] != N + 1); cwr_loop++) { + int prev = N; + for (i = 0; i < D; i++) { + di[i] = prev - sequence_sorted[i]; + prev = sequence_sorted[i]; + } + di[D] = sequence_sorted[D - 1]; + + asset_float sum_log_di_factorial = 0.f; + for (i = 0; i <= D; i++) { + sum_log_di_factorial += log_factorial[di[i]]; + } + + asset_float colsum; + const asset_float colsum_base = logK - sum_log_di_factorial; + const float *log_du_row = log_du; + for (row = 0; row < block_width; row++) { + colsum = colsum_base; + for (i = 0; i <= D; i++) { + if (di[i] != 0) { + colsum += di[i] * log_du_row[i]; + } + } + P_thread[row] += exp(colsum); + log_du_row += D + 1; + } + + combinations_with_replacement(sequence_sorted); + } + } + + for (row = threadIdx.x; row < block_width + threadIdx.x; row++) { + // Reduce atomicAdd conflicts by adding threadIdx.x to each row + atomicAdd(P_total + row % block_width, P_thread[row % block_width]); + } + + __syncthreads(); + + for (row = threadIdx.x; row < block_width; row += blockDim.x) { + atomicAdd(P_out + row + l_shift, P_total[row]); + } +} + + +/** + * Creates a flattened matrix (D-1)*N that will be used + * to map the iteration ID to a sequence_sorted array. + */ +ULL create_iteration_table() { + ULL *m = (ULL*) calloc(D * N, sizeof(ULL)); + unsigned int row, col; + for (col = 0; col < N; col++) { + m[col] = col; + } + for (row = 1; row < D; row++) { + ULL sum = 0; + for (col = row + 1; col < N; col++) { + sum += m[(row - 1) * N + col]; + m[row * N + col] = sum; + } + } + + ULL it_todo = 1; + double it_todo_double = 1.0; + for (row = 0; row < D; row++) { + it_todo += m[row * N + N-1]; + it_todo_double += m[row * N + N-1]; + } + + // check for the integer overflow; + // values greater than ULONG_MAX are not supported by CUDA + assert(it_todo_double <= ULONG_MAX); + + cudaMemcpyToSymbol(iteration_table, m, sizeof(ULL) * D * N); + + cudaMemcpyToSymbol((const void*) &ITERATIONS_TODO, (const void*) &it_todo, sizeof(ULL)); + + free(m); + + return it_todo; +} + + +// For debugging purposes only +void print_constants() { + int i, col; + printf(">>> iteration_table\n"); + ULL iteration_table_host[D * N]; + cudaMemcpyFromSymbol(iteration_table_host, iteration_table, sizeof(ULL) * D * N); + int row; + for (row = 0; row < D; row++) { + for (col = 0; col < N; col++) { + printf("%10llu ", iteration_table_host[row * N + col]); + } + printf("\n"); + } + printf("\n"); + + ULL it_todo_host; + cudaMemcpyFromSymbol((void*)&it_todo_host, (const void*)&ITERATIONS_TODO, sizeof(ULL)); + printf(">>> ITERATIONS_TODO = %llu\n", it_todo_host); + + unsigned int l_block; + cudaMemcpyFromSymbol((void*)&l_block, (const void*)&L_BLOCK, sizeof(l_block)); + printf(">>> L_BLOCK = %u\n", l_block); + + ULL l_num_blocks; + cudaMemcpyFromSymbol((void*)&l_num_blocks, (const void*)&L_NUM_BLOCKS, sizeof(ULL)); + printf(">>> L_NUM_BLOCKS = %llu\n", l_num_blocks); + + asset_float logK_host; + cudaMemcpyFromSymbol((void*)&logK_host, (const void*)&logK, sizeof(asset_float)); + printf(">>> logK = %f\n\n", logK_host); + + asset_float log_factorial_host[N + 1]; + cudaMemcpyFromSymbol(log_factorial_host, log_factorial, sizeof(asset_float) * (N+1)); + printf(">>> log_factorial\n"); + for (i = 0; i <= N; i++) { + printf("%f ", log_factorial_host[i]); + } + printf("\n\n"); +} + + +/** + * ASSET jsf_uniform_orderstat_3d host function to calculate P_total. + * The result of a calculation is saved in P_total_host array. + * + * @param P_total_host a pointer to P_total array to be calculated + * @param log_du_host input flattened L*(D+1) matrix of log_du values + */ +void jsf_uniform_orderstat_3d(asset_float *P_total_host, const float *log_du_host) { + ULL it_todo = create_iteration_table(); + + asset_float logK_host = 0.f; + asset_float log_factorial_host[N + 1] = {0.f}; + + int i; + for (i = 1; i <= N; i++) { + logK_host += log((asset_float) i); + log_factorial_host[i] = logK_host; + } + + cudaMemcpyToSymbol((const void*) &logK, (const void*) &logK_host, sizeof(asset_float)); + cudaMemcpyToSymbol(log_factorial, log_factorial_host, sizeof(asset_float) * (N + 1)); + + cudaDeviceProp device_prop; + cudaGetDeviceProperties(&device_prop, 0); + const unsigned int max_l_block = device_prop.sharedMemPerBlock / (sizeof(asset_float) * (D + 2)); + + /** + * It's important to match the width (tile) of + * a block with N_THREADS, if N_THREADS < L. + */ + unsigned int n_threads = min_macros(N_THREADS, min_macros(max_l_block, device_prop.maxThreadsPerBlock)); + if (n_threads > device_prop.warpSize) { + // It's more efficient to make the number of threads + // a multiple of the warp size (32). + n_threads -= n_threads % device_prop.warpSize; + } + const unsigned int l_block = min_macros(n_threads, L); + cudaMemcpyToSymbol((const void*) &L_BLOCK, (const void*) &l_block, sizeof(l_block)); + + const ULL l_num_blocks = (ULL) ceil(L * 1.f / l_block); + cudaMemcpyToSymbol((const void*) &L_NUM_BLOCKS, (const void*) &l_num_blocks, sizeof(ULL)); + + asset_float *P_total_device; + + // Initialize P_total_device with zeros. + // Note that values other than 0x00 or 0xFF (NaN) won't work + // with cudaMemset when the data type is float or double. + cudaMalloc((void**)&P_total_device, sizeof(asset_float) * L); + cudaMemset(P_total_device, 0, sizeof(asset_float) * L); + + ULL grid_size = (ULL) ceil(it_todo * 1.f / (n_threads * CWR_LOOPS)); + grid_size = min_macros(grid_size, device_prop.maxGridSize[0]); + if (grid_size > l_num_blocks) { + // make grid_size divisible by l_num_blocks + grid_size -= grid_size % l_num_blocks; + } else { + // grid_size must be at least l_num_blocks + grid_size = l_num_blocks; + } + + printf(">>> it_todo=%llu, grid_size=%llu, N_THREADS=%u\n\n", it_todo, grid_size, n_threads); + + float *log_du_device; + cudaMalloc((void**)&log_du_device, sizeof(float) * L * (D + 1)); + cudaMemcpy(log_du_device, log_du_host, sizeof(float) * L * (D + 1), cudaMemcpyHostToDevice); + +#if ASSET_DEBUG + print_constants(); +#endif + + // Wait for asynchronous memory copies to finish. + // Don't know if this call is needed. + cudaDeviceSynchronize(); + + // Executing kernel + const unsigned long shared_mem_used = sizeof(asset_float) * l_block + sizeof(float) * l_block * (D + 1); + jsf_uniform_orderstat_3d_kernel<<>>(P_total_device, log_du_device); + + // Transfer data back to host memory + cudaMemcpy(P_total_host, P_total_device, sizeof(asset_float) * L, cudaMemcpyDeviceToHost); + + cudaFree(P_total_device); + cudaFree(log_du_device); +} + + +int main(int argc, char* argv[]) { + // compile command: nvcc -o asset.o asset.cu + // (run after you fill the template keys L, N, D, etc.) + if (argc != 3) { + fprintf(stderr, "Usage: ./asset.o /path/to/log_du.txt /path/to/P_total_output.txt\n"); + return 1; + } + char *log_du_path = argv[1]; + char *P_total_path = argv[2]; + + FILE *log_du_file = fopen(log_du_path, "r"); + + if (log_du_file == NULL) { + fprintf(stderr, "File '%s' not found\n", log_du_path); + return 1; + } + + float log_du_host[L * (D + 1)]; + uint32_t row, col, pos; + for (row = 0; row < L; row++) { + for (col = 0; col <= D; col++) { + pos = row * (D + 1) + col; + int read_floats = fscanf(log_du_file, "%f", log_du_host + pos); + assert(read_floats == 1); + } + } + fclose(log_du_file); + + asset_float P_total[L]; + jsf_uniform_orderstat_3d(P_total, (const float*) log_du_host); + + FILE *P_total_file = fopen(P_total_path, "w"); + if (P_total_file == NULL) { + fprintf(stderr, "Could not open '%s' for writing.\n", P_total_path); + return 1; + } + for (col = 0; col < L; col++) { + fprintf(P_total_file, "%f\n", P_total[col]); + } + fclose(P_total_file); + + return 0; +} diff --git a/elephant/test/test_asset.py b/elephant/test/test_asset.py index 73fef2b5f..255f9c7e6 100644 --- a/elephant/test/test_asset.py +++ b/elephant/test/test_asset.py @@ -24,7 +24,7 @@ except ImportError: HAVE_SKLEARN = False else: - import elephant.asset as asset + import elephant.asset.asset as asset HAVE_SKLEARN = True stretchedmetric2d = asset._stretched_metric_2d @@ -269,6 +269,10 @@ def test_intersection_matrix(self): spiketrains_i=[st1, st2], bin_size=bin_size, t_stop_j=5 * pq.ms) + +@unittest.skipUnless(HAVE_SKLEARN, 'requires sklearn') +class TestJSFUniformOrderStat3D(unittest.TestCase): + def test_combinations_with_replacement(self): # Test that _combinations_with_replacement yields the same tuples # as in the original implementation with itertools.product(*lists) @@ -283,18 +287,64 @@ def _wrong_order(a): return False for n in range(1, 15): - for d in range(1, 6): + for d in range(1, min(6, n + 1)): + jsf = asset._JSFUniformOrderStat3D(n=n, d=d) lists = [range(j, n + 1) for j in range(d, 0, -1)] matrix_entries = list( - asset._combinations_with_replacement(n=n, d=d) + jsf._combinations_with_replacement() ) matrix_entries_correct = [ indices for indices in itertools.product(*lists) if not _wrong_order(indices) ] - it_todo = asset._num_iterations(n=n, d=d) self.assertEqual(matrix_entries, matrix_entries_correct) - self.assertEqual(it_todo, len(matrix_entries_correct)) + self.assertEqual(jsf.num_iterations, + len(matrix_entries_correct)) + + def test_next_sequence_sorted(self): + for n in range(1, 15): + for d in range(1, min(6, n + 1)): + jsf = asset._JSFUniformOrderStat3D(n=n, d=d) + for iter_id, seq_sorted_true in enumerate( + jsf._combinations_with_replacement()): + seq_sorted = jsf._next_sequence_sorted(iteration=iter_id) + self.assertEqual(seq_sorted, seq_sorted_true) + + def test_invalid_values(self): + # 1) d > n + self.assertRaises(ValueError, asset._JSFUniformOrderStat3D, n=5, d=6) + + # 2) d does not match the input data shape + d = 4 + jsf = asset._JSFUniformOrderStat3D(n=5, d=d) + u = np.empty((3, d + 1)) + self.assertRaises(ValueError, jsf.compute, u=u) + + def test_point_mass_output(self): + # When N >> D, the expected output is [1, 0] + L, N, D = 2, 50, 2 + jsf = asset._JSFUniformOrderStat3D(n=N, d=D, precision='double') + u = np.arange(L * D, dtype=np.float32).reshape((-1, D)) + u /= np.max(u) + p_out = jsf.compute(u) + assert_array_almost_equal(p_out, [1., 0.]) + + def test_precision(self): + L = 2 + for n in range(1, 10): + for d in range(1, min(6, n + 1)): + u = np.arange(L * d, dtype=np.float32).reshape((-1, d)) + u /= np.max(u) + jsf_double = asset._JSFUniformOrderStat3D(n=n, d=d, + precision='double') + jsf_float = asset._JSFUniformOrderStat3D(n=n, d=d, + precision='float') + P_total_double = jsf_double.compute(u) + P_total_float = jsf_float.compute(u) + # decimal 5 is used because the number of iterations is small + # in practice, the results deviate starting at decimal 3 or 2 + assert_array_almost_equal(P_total_double, P_total_float, + decimal=5) @unittest.skipUnless(HAVE_SKLEARN, 'requires sklearn') @@ -512,15 +562,5 @@ def test_integration_nonsymmetric(self): expected_sses=expected_sses) -def suite(): - suite = unittest.makeSuite(AssetTestCase, 'test') - return suite - - -def run(): - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) - - if __name__ == "__main__": unittest.main() diff --git a/elephant/utils.py b/elephant/utils.py index e31c6172d..0d7b34c46 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -11,6 +11,7 @@ from __future__ import division, print_function, unicode_literals +import ctypes import warnings from functools import wraps @@ -298,3 +299,41 @@ def round_binning_errors(values, tolerance=1e-8): 'behaviour.') values += 0.5 return int(values) + + +def get_cuda_capability_major(): + """ + Extracts CUDA capability major version of the first available Nvidia GPU + card, if detected. Otherwise, return 0. + + Returns + ------- + int + CUDA capability major version. + """ + CUDA_SUCCESS = 0 + for libname in ('libcuda.so', 'libcuda.dylib', 'cuda.dll'): + try: + cuda = ctypes.CDLL(libname) + except OSError: + continue + else: + break + else: + # not found + return 0 + result = cuda.cuInit(0) + if result != CUDA_SUCCESS: + return 0 + device = ctypes.c_int() + # parse the first GPU card only + result = cuda.cuDeviceGet(ctypes.byref(device), 0) + if result != CUDA_SUCCESS: + return 0 + + cc_major = ctypes.c_int() + cc_minor = ctypes.c_int() + cuda.cuDeviceComputeCapability(ctypes.byref(cc_major), + ctypes.byref(cc_minor), + device) + return cc_major.value diff --git a/requirements/requirements-extras.txt b/requirements/requirements-extras.txt index 2a11854b7..c43293b3e 100644 --- a/requirements/requirements-extras.txt +++ b/requirements/requirements-extras.txt @@ -1,3 +1,4 @@ pandas>=0.18.0 scikit-learn>=0.23.2 statsmodels>=0.12.1 +jinja2>=2.11.2 # required for ASSET CUDA From 1ba500ae60dbe670d5a46c2a0217c7d74683d931 Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Mon, 1 Feb 2021 11:24:46 +0100 Subject: [PATCH 09/63] Bin-Shuffling: reimplemented the continuos time version (#397) Also, fixed trial-shuffling, copy -> deepcopy Co-authored-by: dizcza --- elephant/spike_train_surrogates.py | 138 +++++++++++++++++++++++------ 1 file changed, 110 insertions(+), 28 deletions(-) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index db0175729..d0ae7f460 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -584,7 +584,8 @@ def jitter_spikes(spiketrain, bin_size, n_surrogates=1): def bin_shuffling( - binned_spiketrain, max_displacement, n_surrogates=1, sliding=False): + spiketrain, max_displacement, bin_size=None, n_surrogates=1, + sliding=False): """ Bin shuffling surrogate generation. @@ -594,25 +595,45 @@ def bin_shuffling( Parameters ---------- - binned_spiketrain : conv.BinnedSpikeTrain - The binned spiketrain to create surrogates of. + spiketrain : conv.BinnedSpikeTrain or neo.SpikeTrain + The binned spike train or a continuous time spike train + to create surrogates of. max_displacement : int Number of bins that a single spike can be displaced. + bin_size : pq.Quantity or None + the bin size needs to be specified only if a not-binned spike train + is passed to the method n_surrogates : int, optional Number of surrogates to create. Default: 1. sliding : bool, optional - If True, the window is slided bin by bin. + If True, the window is slided bin by bin + (only implemented for binned spike trains). Default: False. Returns ------- - binned_surrogates : list of conv.BinnedSpikeTrain - Each entry of the list is a binned surrogate spiketrain. + binned_surrogates : list of conv.BinnedSpikeTrain or list of neo.SpikeTrain + Each entry of the list is a surrogate spike train either binned or in + continuous time. """ + if isinstance(spiketrain, neo.SpikeTrain): + if bin_size is None: + raise ValueError( + 'If you want to create surrogates from neo.SpikeTrain objects,' + 'you need to specify the bin_size') + if sliding: + warnings.warn( + 'The sliding option is not implemented yet for bin shuffling' + ' on continuos time spike trains. Results are given for' + ' sliding=False.', UserWarning) + return _continuous_time_bin_shuffling( + spiketrain, max_displacement=max_displacement, bin_size=bin_size, + n_surrogates=n_surrogates) + displacement_window = 2 * max_displacement - binned_spiketrain_bool = binned_spiketrain.to_bool_array()[0] + binned_spiketrain_bool = spiketrain.to_bool_array()[0] st_length = len(binned_spiketrain_bool) surrogate_spiketrains = [] @@ -642,9 +663,83 @@ def bin_shuffling( surrogate_spiketrains.append( conv.BinnedSpikeTrain( surrogate_spiketrain, - bin_size=binned_spiketrain.bin_size, - t_start=binned_spiketrain.t_start, - t_stop=binned_spiketrain.t_stop)) + bin_size=spiketrain.bin_size, + t_start=spiketrain.t_start, + t_stop=spiketrain.t_stop)) + return surrogate_spiketrains + + +def _continuous_time_bin_shuffling(spiketrain, max_displacement, bin_size, + n_surrogates=1): + """ + + Parameters + ---------- + spiketrain : neo.SpikeTrain + max_displacement : int + number of bins that a single spike can be displaced + bin_size : pq.Quantity + n_surrogates : int, optional + Default : 1 + + Returns + ------- + list of neo.SpikeTrain + """ + units = spiketrain.units + bin_size = bin_size.rescale(units).item() + t_start = spiketrain.t_start.item() + t_stop = spiketrain.t_stop.item() + spiketrain_shifted = spiketrain.magnitude - t_start + + binned_duration = int((t_stop - t_start) // bin_size) + + bin_indices = (spiketrain_shifted // bin_size).astype(int) + + surrogate_spiketrains = [] + + for surrogate_id in range(n_surrogates): + displacement_window = 2 * max_displacement + for window_start in range( + 0, binned_duration - displacement_window, displacement_window): + # ensure last window is not too long + if window_start + displacement_window > binned_duration: + displacement_window = binned_duration - window_start + random_indices = np.random.permutation(displacement_window) + condition = np.all( + (bin_indices >= window_start, + bin_indices < window_start + displacement_window), + axis=0) + + sliced_bin_indices = bin_indices[condition] + sliced_bin_indices = \ + random_indices[sliced_bin_indices - window_start] \ + + window_start + + bin_indices[condition] = sliced_bin_indices + + bin_remainders = bin_size * np.random.random(len(spiketrain)) + + surrogate_spiketrain = \ + bin_indices * bin_size + bin_remainders + t_start + + # ensure last and first spike being inside the boundaries + surrogate_spiketrain = surrogate_spiketrain[ + np.all((surrogate_spiketrain > t_start, + surrogate_spiketrain < t_stop), + axis=0)] + + surrogate_spiketrain.sort() + + surrogate_spiketrain = neo.SpikeTrain( + surrogate_spiketrain, + units=units, + t_start=t_start, + t_stop=t_stop, + copy=False, + ) + + surrogate_spiketrains.append(surrogate_spiketrain) return surrogate_spiketrains @@ -1180,7 +1275,7 @@ def _trial_shifting(spiketrains, dither, t_starts, t_stops, n_surrogates): """ surrogate_spiketrains = [] for surrogate_id in range(n_surrogates): - copied_spiketrain = copy.copy(spiketrains) + copied_spiketrain = copy.deepcopy(spiketrains) surrogate_spiketrain = [] # looping over all trials for trial_id, single_trial_st in enumerate(copied_spiketrain): @@ -1378,23 +1473,10 @@ def surrogates( return _trial_shifting_of_concatenated_spiketrain( spiketrain, dither=dt, n_surrogates=n_surrogates, **kwargs) if method is bin_shuffling: - binned_spiketrain = conv.BinnedSpikeTrain( - spiketrain, bin_size=kwargs['bin_size']) - bin_size = binned_spiketrain._bin_size - # bin_centers share the same units as bin_size - bin_grid = binned_spiketrain.bin_centers.magnitude max_displacement = int( - dt.rescale(binned_spiketrain.units).item() / bin_size) - binned_surrogates = bin_shuffling(binned_spiketrain, - max_displacement=max_displacement, - n_surrogates=n_surrogates) - surrogate_spiketrains = \ - [neo.SpikeTrain(bin_grid[binned_surr.sparse_matrix.nonzero()[1]], - t_start=spiketrain.t_start, - t_stop=spiketrain.t_stop, - units=binned_spiketrain.units, - sampling_rate=spiketrain.sampling_rate) - for binned_surr in binned_surrogates] - return surrogate_spiketrains + dt.simplified.magnitude / kwargs['bin_size'].simplified.magnitude) + return method( + spiketrain, max_displacement=max_displacement, + bin_size=kwargs['bin_size'], n_surrogates=n_surrogates) # surr_method is 'joint_isi_dithering' or isi_dithering: return method(n_surrogates) From f20f071d487b6cb841ee1ad172e346c5bb8f13ab Mon Sep 17 00:00:00 2001 From: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> Date: Mon, 1 Feb 2021 12:21:38 +0100 Subject: [PATCH 10/63] Account for unidirectional spiketrain->segment links in synchrofact deletion (#398) * Fix a bug in synchrofact deletion when passing the actual segment.spiketrains list to the Synchrotool and performing in-place deletion the spiketrain was overwritten before its index was determined resulting in an error * Fix spiketrain replacement being skipped if the spiketrain is not part of a segment and/or block the `continue` skipped the replacement in the input list * Handle unidirectional segment uplinks --- elephant/spike_train_synchrony.py | 55 ++++++++++++--------- elephant/test/test_spike_train_synchrony.py | 53 ++++++++++++++++++++ 2 files changed, 85 insertions(+), 23 deletions(-) diff --git a/elephant/spike_train_synchrony.py b/elephant/spike_train_synchrony.py index 14c342b39..8953e4b8a 100644 --- a/elephant/spike_train_synchrony.py +++ b/elephant/spike_train_synchrony.py @@ -18,6 +18,7 @@ """ from __future__ import division, print_function, unicode_literals +import warnings from collections import namedtuple from copy import deepcopy @@ -341,33 +342,41 @@ def delete_synchrofacts(self, threshold, in_place=False, mode='delete'): if mode == 'extract': mask = np.invert(mask) new_st = st[mask] - spiketrain_list[idx] = new_st - if in_place: + if in_place and st.segment is not None: segment = st.segment - if segment is None: - continue - # replace link to spiketrain in segment - new_index = self._get_spiketrain_index( - segment.spiketrains, st) - segment.spiketrains[new_index] = new_st + try: + # replace link to spiketrain in segment + new_index = self._get_spiketrain_index( + segment.spiketrains, st) + segment.spiketrains[new_index] = new_st + except ValueError: + # st is not in this segment even though it points to it + warnings.warn(f"The SpikeTrain at index {idx} of the " + "input list spiketrains has a " + "unidirectional uplink to a segment in " + "whose segment.spiketrains list it does not " + "appear. Only the spiketrains in the input " + "list will be replaced. You can suppress " + "this warning by setting " + "spiketrain.segment=None for the input " + "spiketrains.") block = segment.block - if block is None: - continue - - # replace link to spiketrain in groups - for group in block.groups: - try: - idx = self._get_spiketrain_index( - group.spiketrains, - st) - except ValueError: - # st is not in this group, move to next group - continue - - # st found in group, replace with new_st - group.spiketrains[idx] = new_st + if block is not None: + # replace link to spiketrain in groups + for group in block.groups: + try: + idx = self._get_spiketrain_index( + group.spiketrains, + st) + except ValueError: + # st is not in this group, move to next group + continue + + # st found in group, replace with new_st + group.spiketrains[idx] = new_st + spiketrain_list[idx] = new_st return spiketrain_list diff --git a/elephant/test/test_spike_train_synchrony.py b/elephant/test/test_spike_train_synchrony.py index 295f11b83..ea7d67216 100644 --- a/elephant/test/test_spike_train_synchrony.py +++ b/elephant/test/test_spike_train_synchrony.py @@ -283,6 +283,59 @@ def test_spread_0(self): spread=0, mode='delete', in_place=True, deletion_threshold=2) + def test_spiketrains_findable(self): + + # same test as `test_spread_0` with the addition of + # a neo structure: we must not overwrite the spiketrain + # list of the segment before determining the index + + sampling_rate = 1 / pq.s + + segment = neo.Segment() + + segment.spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, + t_stop=20*pq.s), + neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, + t_stop=20*pq.s)] + + segment.create_relationship() + + correct_annotations = np.array([[2, 1, 1, 1, 2, 1], + [2, 1, 1, 1, 2, 1]]) + + self._test_template(segment.spiketrains, correct_annotations, + sampling_rate, spread=0, mode='delete', + in_place=True, deletion_threshold=2) + + def test_unidirectional_uplinks(self): + + # same test as `test_spiketrains_findable` but the spiketrains + # are rescaled first + # the rescaled spiketrains have a unidirectional uplink to segment + # check that this does not cause an error + # check that a UserWarning is issued in this case + + sampling_rate = 1 / pq.s + + segment = neo.Segment() + + segment.spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, + t_stop=20*pq.s), + neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, + t_stop=20*pq.s)] + + segment.create_relationship() + + spiketrains = [st.rescale(pq.s) for st in segment.spiketrains] + + correct_annotations = np.array([[2, 1, 1, 1, 2, 1], + [2, 1, 1, 1, 2, 1]]) + + with self.assertWarns(UserWarning): + self._test_template(spiketrains, correct_annotations, + sampling_rate, spread=0, mode='delete', + in_place=True, deletion_threshold=2) + def test_spread_1(self): # test synchrofact search taking into account adjacent bins From 214d477c74e3d619f7cedfadbec42fcea58d27e0 Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Wed, 3 Feb 2021 08:49:21 +0100 Subject: [PATCH 11/63] Speed up bin shuffling (#400) --- elephant/spike_train_surrogates.py | 35 +++++++++++++++--------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index d0ae7f460..4e9df31ac 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -691,37 +691,38 @@ def _continuous_time_bin_shuffling(spiketrain, max_displacement, bin_size, t_start = spiketrain.t_start.item() t_stop = spiketrain.t_stop.item() spiketrain_shifted = spiketrain.magnitude - t_start + displacement_window = 2 * max_displacement binned_duration = int((t_stop - t_start) // bin_size) bin_indices = (spiketrain_shifted // bin_size).astype(int) - surrogate_spiketrains = [] + split_indices = np.searchsorted( + bin_indices, + np.arange(displacement_window, binned_duration, displacement_window)) + + bin_indices = np.split( + bin_indices, + split_indices) + surrogate_spiketrains = [] for surrogate_id in range(n_surrogates): - displacement_window = 2 * max_displacement - for window_start in range( - 0, binned_duration - displacement_window, displacement_window): - # ensure last window is not too long - if window_start + displacement_window > binned_duration: - displacement_window = binned_duration - window_start + surrogate_bin_indices = np.empty(shape=len(bin_indices), + dtype=np.ndarray) + for i, bin_indices_slice in enumerate(bin_indices): + window_start = i*displacement_window + random_indices = np.random.permutation(displacement_window) - condition = np.all( - (bin_indices >= window_start, - bin_indices < window_start + displacement_window), - axis=0) - - sliced_bin_indices = bin_indices[condition] - sliced_bin_indices = \ - random_indices[sliced_bin_indices - window_start] \ + surrogate_bin_indices[i] = \ + random_indices[bin_indices_slice - window_start] \ + window_start - bin_indices[condition] = sliced_bin_indices + surrogate_bin_indices = np.concatenate(surrogate_bin_indices) bin_remainders = bin_size * np.random.random(len(spiketrain)) surrogate_spiketrain = \ - bin_indices * bin_size + bin_remainders + t_start + surrogate_bin_indices * bin_size + bin_remainders + t_start # ensure last and first spike being inside the boundaries surrogate_spiketrain = surrogate_spiketrain[ From d68a5f8007d53768e0cf24a3bceb200bca443a36 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Wed, 3 Feb 2021 08:49:40 +0100 Subject: [PATCH 12/63] Memory efficient and faster implementation of ASSET pmat analytical (#399) --- elephant/asset/asset.py | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index 5dea91f6a..fb31f52b3 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -1607,30 +1607,29 @@ def probability_matrix_analytical(self, imat=None, print('compute the prob. that each neuron fires in each pair of ' 'bins...') - spike_probs_x = [1. - np.exp(-(rate * self.bin_size).rescale( - pq.dimensionless).magnitude) for rate in fir_rate_x] + rate_bins_x = (fir_rate_x * self.bin_size).simplified.magnitude + spike_probs_x = 1. - np.exp(-rate_bins_x) if symmetric: spike_probs_y = spike_probs_x else: - spike_probs_y = [1. - np.exp(-(rate * self.bin_size).rescale( - pq.dimensionless).magnitude) for rate in fir_rate_y] - - # For each neuron k compute the matrix of probabilities p_ijk that - # neuron k spikes in both bins i and j. (For i = j it's just spike - # probs[k][i]) - spike_prob_mats = [np.outer(probx, proby) for (probx, proby) in - zip(spike_probs_x, spike_probs_y)] + rate_bins_y = (fir_rate_y * self.bin_size).simplified.magnitude + spike_probs_y = 1. - np.exp(-rate_bins_y) # Compute the matrix Mu[i, j] of parameters for the Poisson # distributions which describe, at each (i, j), the approximated # overlap probability. This matrix is just the sum of the probability - # matrices computed above - + # matrices p_ijk computed for each neuron k: + # p_ijk is the probability that neuron k spikes in both bins i and j. + # The sum of outer products is equivalent to a dot product. if self.verbose: print( "compute the probability matrix by Le Cam's approximation...") - - Mu = np.sum(spike_prob_mats, axis=0) + Mu = spike_probs_x.T.dot(spike_probs_y) + # A straightforward implementation is: + # pmat_shape = spike_probs_x.shape[1], spike_probs_y.shape[1] + # Mu = np.zeros(pmat_shape, dtype=np.float64) + # for probx, proby in zip(spike_probs_x, spike_probs_y): + # Mu += np.outer(probx, proby) # Compute the probability matrix obtained from imat using the Poisson # pdfs From f56a62a68c16197bc141773117650ddd120222c8 Mon Sep 17 00:00:00 2001 From: Andrew Davison Date: Mon, 8 Feb 2021 09:28:23 +0100 Subject: [PATCH 13/63] missing comma in BibTeX entry (#401) Fixed Elephant citation BibTex --- doc/citation.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/citation.rst b/doc/citation.rst index a6779319e..4e4fb242b 100644 --- a/doc/citation.rst +++ b/doc/citation.rst @@ -18,7 +18,7 @@ A BibTeX entry for LaTeX users is: booktitle = {Neuroinformatics 2018}, title = {{C}ollaborative {HPC}-enabled workflows on the {HBP} {C}ollaboratory using the {E}lephant framework}, pages = {P19}, - year = {2018} + year = {2018}, doi = {10.12751/incf.ni2018.0019}, url = {https://abstracts.g-node.org/conference/NI2018/abstracts#/uuid/023bec4e-0c35-4563-81ce-2c6fac282abd}, } @@ -31,4 +31,4 @@ Further publications directly related to Elephant development .. bibliography:: bib/elephant.bib :labelprefix: citations- :keyprefix: citations- - :style: unsrt \ No newline at end of file + :style: unsrt From 5e95f77ea6ee75bd8ba957adda5279146f10e606 Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Fri, 12 Feb 2021 18:37:58 +0100 Subject: [PATCH 14/63] Replaced custom TestSuite runner with unittest.main() (#403) --- elephant/test/test_spectral.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index 801bd8246..d7f1e15bf 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -322,11 +322,5 @@ def test_welch_cohere_multidim_input(self): np.all(phase_lag_neo_1dim[:, 0] == phase_lag_neo[:, 0])) -def suite(): - suite = unittest.makeSuite(WelchPSDTestCase, 'test') - return suite - - if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) From 68b3243ebf2cdb5b57a48e3cc087c0700621f527 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Wed, 24 Feb 2021 10:07:35 +0100 Subject: [PATCH 15/63] BinnedSpikeTrain optional CSC format (#402) * BinnedSpikeTrain optional CSC format * BinnedSpikeTrain.binarize() 'copy' arg is back --- elephant/conversion.py | 124 +++++++++++++++++++------------ elephant/statistics.py | 4 +- elephant/test/test_conversion.py | 85 +++++++++++++-------- 3 files changed, 130 insertions(+), 83 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index 1f6ffa8b8..b3cbd7c0b 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -274,6 +274,10 @@ class BinnedSpikeTrain(object): Tolerance for rounding errors in the binning process and in the input data Default: 1e-8 + sparse_format : {'csr', 'csc'}, optional + The sparse matrix format. By default, CSR format is used to perform + slicing and computations efficiently. + Default: 'csr' Raises ------ @@ -323,7 +327,11 @@ class BinnedSpikeTrain(object): @deprecated_alias(binsize='bin_size', num_bins='n_bins') def __init__(self, spiketrains, bin_size=None, n_bins=None, t_start=None, - t_stop=None, tolerance=1e-8): + t_stop=None, tolerance=1e-8, sparse_format="csr"): + if sparse_format not in ("csr", "csc"): + raise ValueError(f"Invalid 'sparse_format': {sparse_format}. " + "Available: 'csr' and 'csc'") + # Converting spiketrains to a list, if spiketrains is one # SpikeTrain object if isinstance(spiketrains, neo.SpikeTrain): @@ -339,7 +347,8 @@ def __init__(self, spiketrains, bin_size=None, n_bins=None, t_start=None, # Check all parameter, set also missing values self._resolve_input_parameters(spiketrains) # Now create the sparse matrix - self.sparse_matrix = self._create_sparse_matrix(spiketrains) + self.sparse_matrix = self._create_sparse_matrix( + spiketrains, sparse_format=sparse_format) @property def shape(self): @@ -369,13 +378,10 @@ def num_bins(self): return self.n_bins def __repr__(self): - return "{klass}(t_start={t_start}, t_stop={t_stop}, " \ - "bin_size={bin_size}; shape={shape})".format( - klass=type(self).__name__, - t_start=self.t_start, - t_stop=self.t_stop, - bin_size=self.bin_size, - shape=self.shape) + return f"{type(self).__name__}(t_start={self.t_start}, " \ + f"t_stop={self.t_stop}, bin_size={self.bin_size}; " \ + f"shape={self.shape}, " \ + f"format={self.sparse_matrix.__class__.__name__})" def rescale(self, units): """ @@ -590,7 +596,7 @@ def to_sparse_array(self): Returns ------- - scipy.sparse.csr_matrix + scipy.sparse.csr_matrix or scipy.sparse.csc_matrix Sparse matrix, version with spike counts. See also @@ -611,7 +617,7 @@ def to_sparse_bool_array(self): Returns ------- - scipy.sparse.csr_matrix + scipy.sparse.csr_matrix or scipy.sparse.csc_matrix Sparse matrix, binary, boolean version. See also @@ -638,7 +644,8 @@ def __eq__(self, other): return False sp1 = self.sparse_matrix sp2 = other.sparse_matrix - if sp1.shape != sp2.shape or sp1.data.shape != sp2.data.shape: + if sp1.__class__ is not sp2.__class__ or sp1.shape != sp2.shape \ + or sp1.data.shape != sp2.data.shape: return False return (sp1.data == sp2.data).all() and \ (sp1.indptr == sp2.indptr).all() and \ @@ -662,11 +669,18 @@ def copy(self): tolerance=self.tolerance) def __iter_sparse_matrix(self): + spmat = self.sparse_matrix + if isinstance(spmat, sps.csc_matrix): + warnings.warn("The sparse matrix format is CSC. For better " + "performance, specify the CSR format while " + "constructing a " + "BinnedSpikeTrain(sparse_format='csr')") + spmat = spmat.tocsr() # taken from csr_matrix.__iter__() i0 = 0 - for i1 in self.sparse_matrix.indptr[1:]: - indices = self.sparse_matrix.indices[i0:i1] - data = self.sparse_matrix.data[i0:i1] + for i1 in spmat.indptr[1:]: + indices = spmat.indices[i0:i1] + data = spmat.data[i0:i1] yield indices, data i0 = i1 @@ -1000,15 +1014,12 @@ def to_array(self, dtype=None): scipy.sparse.csr_matrix.toarray """ - spmat = self.sparse_matrix - if dtype is not None and dtype != spmat.data.dtype: - # avoid a copy - spmat = sps.csr_matrix( - (spmat.data.astype(dtype), spmat.indices, spmat.indptr), - shape=spmat.shape) - return spmat.toarray() - - def binarize(self, copy=None): + array = self.sparse_matrix.toarray() + if dtype is not None: + array = array.astype(dtype) + return array + + def binarize(self, copy=True): """ Clip the internal array (no. of spikes in a bin) to `0` (no spikes) or `1` (at least one spike) values only. @@ -1016,29 +1027,38 @@ def binarize(self, copy=None): Parameters ---------- copy : bool, optional - Deprecated parameter. It has no effect. + If True, a **shallow** copy - a view of `BinnedSpikeTrain` - is + returned with the data array filled with zeros and ones. Otherwise, + the binarization (clipping) is done in-place. A shallow copy + means that :attr:`indices` and :attr:`indptr` of a sparse matrix + is shared with the original sparse matrix. Only the data is copied. + If you want to perform a deep copy, call + :func:`BinnedSpikeTrain.copy` prior to binarizing. + Default: True Returns ------- - bst : BinnedSpikeTrainView - A view of `BinnedSpikeTrain` with a sparse matrix containing - data clipped to `0`s and `1`s. + bst : BinnedSpikeTrain or BinnedSpikeTrainView + A (view of) `BinnedSpikeTrain` with the sparse matrix data clipped + to zeros and ones. """ - if copy is not None: - warnings.warn("'copy' parameter is deprecated - a view is always " - "returned; set this parameter to None.", - DeprecationWarning) spmat = self.sparse_matrix - spmat = sps.csr_matrix( - (spmat.data.clip(max=1), spmat.indices, spmat.indptr), - shape=spmat.shape, copy=False) - bst = BinnedSpikeTrainView(t_start=self._t_start, - t_stop=self._t_stop, - bin_size=self._bin_size, - units=self.units, - sparse_matrix=spmat, - tolerance=self.tolerance) + if copy: + data = np.ones(len(spmat.data), dtype=spmat.data.dtype) + spmat = spmat.__class__( + (data, spmat.indices, spmat.indptr), + shape=spmat.shape, copy=False) + bst = BinnedSpikeTrainView(t_start=self._t_start, + t_stop=self._t_stop, + bin_size=self._bin_size, + units=self.units, + sparse_matrix=spmat, + tolerance=self.tolerance) + else: + spmat.data[:] = 1 + bst = self + return bst @property @@ -1053,11 +1073,11 @@ def sparsity(self): num_nonzero = self.sparse_matrix.data.shape[0] return num_nonzero / np.prod(self.sparse_matrix.shape) - def _create_sparse_matrix(self, spiketrains): + def _create_sparse_matrix(self, spiketrains, sparse_format): """ - Converts `neo.SpikeTrain` objects to a sparse matrix - (`scipy.sparse.csr_matrix`), which contains the binned spike times, and - stores it in :attr:`_sparse_mat_u`. + Converts `neo.SpikeTrain` objects to a scipy sparse matrix, which + contains the binned spike times, and + stores it in :attr:`sparse_matrix`. Parameters ---------- @@ -1069,9 +1089,15 @@ def _create_sparse_matrix(self, spiketrains): # The data type for numeric values data_dtype = np.int32 + if sparse_format == 'csr': + sparse_format = sps.csr_matrix + else: + # csc + sparse_format = sps.csc_matrix + if not _check_neo_spiketrain(spiketrains): # a binned numpy array - sparse_matrix = sps.csr_matrix(spiketrains, dtype=data_dtype) + sparse_matrix = sparse_format(spiketrains, dtype=data_dtype) return sparse_matrix # Get index dtype that can accomodate the largest index @@ -1120,9 +1146,9 @@ def _create_sparse_matrix(self, spiketrains): column_ids = np.hstack(column_ids) row_ids = np.hstack(row_ids) - sparse_matrix = sps.csr_matrix((counts, (row_ids, column_ids)), - shape=shape, dtype=data_dtype, - copy=False) + sparse_matrix = sparse_format((counts, (row_ids, column_ids)), + shape=shape, dtype=data_dtype, + copy=False) return sparse_matrix diff --git a/elephant/statistics.py b/elephant/statistics.py index bce470403..e79f72bde 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -918,7 +918,7 @@ def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, bin_size=bin_size) if binary: - bs = bs.binarize() + bs = bs.binarize(copy=False) bin_hist = bs.get_num_of_spikes(axis=0) # Flatten array bin_hist = np.ravel(bin_hist) @@ -1309,7 +1309,7 @@ def _epoch_with_spread(self): tolerance=self.tolerance) if self.binary: - bst = bst.binarize() + bst = bst.binarize(copy=False) bincount = bst.get_num_of_spikes(axis=0) nonzero_indices = np.nonzero(bincount)[0] diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index abb72bafd..a540228ec 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -195,6 +195,19 @@ def setUp(self): self.bin_size = 1 * pq.s self.tolerance = 1e-8 + def test_binarize(self): + spiketrains = [self.spiketrain_a, self.spiketrain_b, + self.spiketrain_a, self.spiketrain_b] + for sparse_format in ("csr", "csc"): + bst = cv.BinnedSpikeTrain(spiketrains=spiketrains, + bin_size=self.bin_size, + sparse_format=sparse_format) + bst_bin = bst.binarize(copy=True) + bst_copy = bst.copy() + assert_array_equal(bst_bin.to_array(), bst.to_bool_array()) + bst_copy.sparse_matrix.data[:] = 1 + self.assertEqual(bst_bin, bst_copy) + def test_slice(self): spiketrains = [self.spiketrain_a, self.spiketrain_b, self.spiketrain_a, self.spiketrain_b] @@ -254,32 +267,38 @@ def test_time_slice(self): def test_to_spike_trains(self): np.random.seed(1) - bst1 = cv.BinnedSpikeTrain( - spiketrains=[self.spiketrain_a, self.spiketrain_b], - bin_size=self.bin_size - ) spiketrains = [homogeneous_poisson_process(rate=10 * pq.Hz, t_start=-1 * pq.s, t_stop=10 * pq.s)] - bst2 = cv.BinnedSpikeTrain(spiketrains=spiketrains, - bin_size=300 * pq.ms) - for bst in (bst1, bst2): - for spikes in ("random", "left", "center"): - spiketrains_gen = bst.to_spike_trains(spikes=spikes, - annotate_bins=True) - for st, indices in zip(spiketrains_gen, bst.spike_indices): - # check sorted - self.assertTrue((np.diff(st.magnitude) > 0).all()) - assert_array_equal(st.array_annotations['bins'], indices) - self.assertEqual(st.annotations['bin_size'], bst.bin_size) - self.assertEqual(st.t_start, bst.t_start) - self.assertEqual(st.t_stop, bst.t_stop) - bst_same = cv.BinnedSpikeTrain(spiketrains_gen, - bin_size=bst.bin_size) - self.assertEqual(bst_same, bst) - - # invalid mode - self.assertRaises(ValueError, bst.to_spike_trains, spikes='right') + for sparse_format in ("csr", "csc"): + bst1 = cv.BinnedSpikeTrain( + spiketrains=[self.spiketrain_a, self.spiketrain_b], + bin_size=self.bin_size, sparse_format=sparse_format + ) + bst2 = cv.BinnedSpikeTrain(spiketrains=spiketrains, + bin_size=300 * pq.ms, + sparse_format=sparse_format) + for bst in (bst1, bst2): + for spikes in ("random", "left", "center"): + spiketrains_gen = bst.to_spike_trains(spikes=spikes, + annotate_bins=True) + for st, indices in zip(spiketrains_gen, bst.spike_indices): + # check sorted + self.assertTrue((np.diff(st.magnitude) > 0).all()) + assert_array_equal(st.array_annotations['bins'], + indices) + self.assertEqual(st.annotations['bin_size'], + bst.bin_size) + self.assertEqual(st.t_start, bst.t_start) + self.assertEqual(st.t_stop, bst.t_stop) + bst_same = cv.BinnedSpikeTrain(spiketrains_gen, + bin_size=bst.bin_size, + sparse_format=sparse_format) + self.assertEqual(bst_same, bst) + + # invalid mode + self.assertRaises(ValueError, bst.to_spike_trains, + spikes='right') def test_get_num_of_spikes(self): spiketrains = [self.spiketrain_a, self.spiketrain_b] @@ -288,14 +307,16 @@ def test_get_num_of_spikes(self): bin_size=1 * pq.s, t_start=0 * pq.s) self.assertEqual(binned.get_num_of_spikes(), len(binned.spike_indices[0])) - binned_matrix = cv.BinnedSpikeTrain(spiketrains, n_bins=10, - bin_size=1 * pq.s) - n_spikes_per_row = binned_matrix.get_num_of_spikes(axis=1) - n_spikes_per_row_from_indices = list(map(len, - binned_matrix.spike_indices)) - assert_array_equal(n_spikes_per_row, n_spikes_per_row_from_indices) - self.assertEqual(binned_matrix.get_num_of_spikes(), - sum(n_spikes_per_row_from_indices)) + for sparse_format in ("csr", "csc"): + binned_matrix = cv.BinnedSpikeTrain(spiketrains, n_bins=10, + bin_size=1 * pq.s, + sparse_format=sparse_format) + n_spikes_per_row = binned_matrix.get_num_of_spikes(axis=1) + n_spikes_per_row_from_indices = list( + map(len, binned_matrix.spike_indices)) + assert_array_equal(n_spikes_per_row, n_spikes_per_row_from_indices) + self.assertEqual(binned_matrix.get_num_of_spikes(), + sum(n_spikes_per_row_from_indices)) def test_binned_spiketrain_sparse(self): a = neo.SpikeTrain([1.7, 1.8, 4.3] * pq.s, t_stop=10.0 * pq.s) @@ -662,7 +683,7 @@ def test_repr(self): bin_size=1 * pq.ms) self.assertEqual(repr(bst), "BinnedSpikeTrain(t_start=1.0 s, " "t_stop=1.01 s, bin_size=0.001 s; " - "shape=(1, 10))") + "shape=(1, 10), format=csr_matrix)") def test_binned_sparsity(self): train = neo.SpikeTrain(np.arange(10), t_stop=10 * pq.s, units=pq.s) From e56b1ac9f913ba9c41538a1d87156ab049e0fa05 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Thu, 25 Feb 2021 15:59:44 +0100 Subject: [PATCH 16/63] PyCUDA and PyOpenCL backends for ASSET joint prob. matrix calculation (#404) * accelerated pmat_neighbors function * cluster_matrix_entries with chunking --- .travis.yml | 7 +- MANIFEST.in | 2 + doc/install.rst | 60 ++ doc/reference/asset.rst | 2 + doc/tutorials/asset.ipynb | 6 +- elephant/asset/asset.py | 902 ++++++++++++++---- elephant/asset/joint_pmat.cl | 198 ++++ elephant/asset/joint_pmat.cu | 169 ++++ .../{asset.template.cu => joint_pmat_old.cu} | 159 +-- elephant/asset/pmat_neighbors.cl | 46 + elephant/asset/pmat_neighbors.cu | 52 + elephant/test/test_asset.py | 230 ++++- elephant/utils.py | 6 +- requirements/environment.yml | 1 + requirements/requirements-cuda.txt | 1 + requirements/requirements-opencl.txt | 2 + setup.py | 2 +- 17 files changed, 1594 insertions(+), 251 deletions(-) create mode 100644 elephant/asset/joint_pmat.cl create mode 100644 elephant/asset/joint_pmat.cu rename elephant/asset/{asset.template.cu => joint_pmat_old.cu} (70%) create mode 100644 elephant/asset/pmat_neighbors.cl create mode 100644 elephant/asset/pmat_neighbors.cu create mode 100644 requirements/requirements-cuda.txt create mode 100644 requirements/requirements-opencl.txt diff --git a/.travis.yml b/.travis.yml index d52ea2f95..bfb85e2ba 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,11 +9,12 @@ addons: matrix: include: - - name: "pip 3.6 requirements-extras" + - name: "conda 3.6 extras,opencl" python: 3.6 - env: DISTRIB="pip" + env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin before_script: + - conda install -c conda-forge pyopencl oclgrind clang=9.0.1 - pip install -r requirements/requirements-extras.txt - pip install mpi4py script: mpiexec -n 1 python -m mpi4py.futures -m nose --with-coverage --cover-package=elephant @@ -56,7 +57,7 @@ install: sed -i '/mpi4py/d' requirements/environment.yml; conda env create -f requirements/environment.yml; conda activate elephant; - pip list; + conda list; else pip install -r requirements/requirements.txt; fi diff --git a/MANIFEST.in b/MANIFEST.in index 49ec5660f..6d901d47b 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -8,6 +8,7 @@ include elephant/current_source_density_src/README.md include elephant/current_source_density_src/test_data.mat include elephant/spade_src/LICENSE recursive-include elephant/spade_src *.so *.pyd +include elephant/asset/* include elephant/test/spike_extraction_test_data.txt recursive-include doc * prune doc/_build @@ -15,4 +16,5 @@ prune doc/tutorials/.ipynb_checkpoints prune doc/reference/toctree include doc/reference/toctree/kernels/* recursive-exclude * *.h5 +recursive-exclude * *.nix recursive-exclude * *~ diff --git a/doc/install.rst b/doc/install.rst index 6a01b5f67..a86458b69 100644 --- a/doc/install.rst +++ b/doc/install.rst @@ -148,6 +148,66 @@ For more information, refer to `mpi4py `_ documentation. +CUDA and OpenCL support +----------------------- + +:ref:`asset` module supports CUDA and OpenCL. These are experimental features. +You can have one, both, or none installed in your system. + +.. tabs:: + + .. tab:: CUDA + + To leverage CUDA acceleration on an NVIDIA GPU card, `CUDA toolkit + `_ must installed on + your system. Then run the following command in a terminal: + + .. code-block:: sh + + pip install pycuda + + In case you experience issues installing PyCUDA, `this guide + `_ offers a step-by-step + installation manual. + + If PyCUDA is detected and installed, CUDA backend is used by default in + Elephant ASSET module. To turn off CUDA support, set ``ELEPHANT_USE_CUDA`` + environment flag to ``0``. + + + .. tab:: OpenCL + + If you have a laptop with a built-in Intel Graphics Card, you can still + leverage significant performance optimization with OpenCL backend. + The simplest way to install PyOpenCL is to run a conda command: + + .. code-block:: sh + + conda install -c conda-forge pyopencl intel-compute-runtime + + However, if you have root (sudo) privileges, it's recommended to install + up-to-date `Intel Graphics Compute Runtime + `_ system-wide and then + install PyOpenCL as follows: + + .. code-block:: sh + + conda install -c conda-forge pyopencl ocl-icd-system + + Set ``ELEPHANT_USE_OPENCL`` environment flag to ``0`` to turn off + PyOpenCL support. + + .. note:: + + Make sure you've disabled GPU Hangcheck as described in the + `Intel GPU developers documentation `_. Do it with caution - + using your graphics card to perform computations may make the system + unresponsive until the compute program terminates. + + Dependencies ------------ diff --git a/doc/reference/asset.rst b/doc/reference/asset.rst index 59204c9d2..c2af18843 100644 --- a/doc/reference/asset.rst +++ b/doc/reference/asset.rst @@ -1,3 +1,5 @@ +.. _asset: + =================================================== Analysis of Sequences of Synchronous EvenTs (ASSET) =================================================== diff --git a/doc/tutorials/asset.ipynb b/doc/tutorials/asset.ipynb index c5edb8578..bb2e7e328 100644 --- a/doc/tutorials/asset.ipynb +++ b/doc/tutorials/asset.ipynb @@ -35,6 +35,7 @@ }, "outputs": [], "source": [ + "import os\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import quantities as pq\n", @@ -248,7 +249,7 @@ "\n", "The third step is postprocessing of the analytical probability matrix `pmat`, obtained from the previous step. Centered at each (i,j) entry of `pmat` matrix, we apply a diagonal kernel with shape `filter_shape` and select the top `nr_largest` probabilities of (i,j) neighborhood (defined by `filter_shape`), and compute the significance of these `nr_largest` joint neighbor probabilities. The resultant `jmat` matrix is a \"dilated\" version of `imat`.\n", "\n", - "This step is most time consuming." + "This step is most time consuming. If you have PyCUDA or PyOpenCL installed, set `ELEPHANT_USE_CUDA` or `ELEPHANT_USE_OPENCL` environment flag to `1`." ] }, { @@ -270,7 +271,8 @@ } ], "source": [ - "# hint: try different filter_shapes, e.g. filter_shape=(7,3)\n", + "os.environ['ELEPHANT_USE_OPENCL'] = '0'\n", + "# try different filter_shapes, e.g. filter_shape=(7,3)\n", "jmat = asset_obj.joint_probability_matrix(pmat, filter_shape=(11, 3), n_largest=3)" ] }, diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index fb31f52b3..653962c19 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -99,11 +99,13 @@ """ from __future__ import division, print_function, unicode_literals +import math import os import subprocess import sys import tempfile import warnings +from pathlib import Path import neo import numpy as np @@ -111,6 +113,7 @@ import scipy.spatial import scipy.stats from sklearn.cluster import dbscan +from sklearn.metrics import pairwise_distances, pairwise_distances_chunked from tqdm import trange, tqdm import elephant.conversion as conv @@ -142,19 +145,6 @@ ] -def _is_cuda_available(): - # a silly way to check for CUDA support - # experimental: should not be public API - try: - subprocess.run(["nvcc", "-V"], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE).check_returncode() - available = True - except (OSError, subprocess.CalledProcessError): - available = False - return available - - # ============================================================================= # Some Utility Functions to be dealt with in some way or another # ============================================================================= @@ -337,7 +327,7 @@ def _analog_signal_step_interp(signal, times): # ============================================================================= -def _stretched_metric_2d(x, y, stretch, ref_angle): +def _stretched_metric_2d(x, y, stretch, ref_angle, working_memory=None): r""" Given a list of points on the real plane, identified by their abscissa `x` and ordinate `y`, compute a stretched transformation of the Euclidean @@ -382,29 +372,66 @@ def _stretched_metric_2d(x, y, stretch, ref_angle): # Create the array of points (one per row) for which to compute the # stretched distance - points = np.vstack([x, y]).T + points = np.column_stack([x, y]) + + x_array = np.expand_dims(x, axis=0) + y_array = np.expand_dims(y, axis=0) + + def calculate_stretch_mat(theta_mat, D_mat): + # Transform [-pi, pi] back to [-pi/2, pi/2] + theta_mat[theta_mat < -np.pi / 2] += np.pi + theta_mat[theta_mat > np.pi / 2] -= np.pi + + # Compute the matrix of stretching factors for each pair of points. + # Equivalent to: + # stretch_mat = 1 + (stretch - 1.) * np.abs(np.sin(alpha - theta)) + _stretch_mat = np.subtract(alpha, theta_mat, out=theta_mat) + _stretch_mat = np.sin(_stretch_mat, out=_stretch_mat) + _stretch_mat = np.abs(_stretch_mat, out=_stretch_mat) + _stretch_mat = np.multiply(stretch - 1, _stretch_mat, out=_stretch_mat) + _stretch_mat = np.add(1, _stretch_mat, out=_stretch_mat) + + _stretch_mat = np.multiply(D_mat, _stretch_mat, out=_stretch_mat) + + return _stretch_mat - # Compute the matrix D[i, j] of euclidean distances among points i and j - D = scipy.spatial.distance_matrix(points, points) + if working_memory is None: + # Compute the matrix D[i, j] of euclidean distances among points + # i and j + D = pairwise_distances(points) - # Compute the angular coefficients of the line between each pair of points - x_array = np.tile(x, reps=(len(x), 1)) - y_array = np.tile(y, reps=(len(y), 1)) - dX = x_array.T - x_array # dX[i,j]: x difference between points i and j - dY = y_array.T - y_array # dY[i,j]: y difference between points i and j + # Compute the angular coefficients of the line between each pair of + # points - # Compute the matrix Theta of angles between each pair of points - theta = np.arctan2(dY, dX) + # dX[i,j]: x difference between points i and j + # dY[i,j]: y difference between points i and j + dX = x_array.T - x_array + dY = y_array.T - y_array - # Transform [-pi, pi] back to [-pi/2, pi/2] - theta[theta < -np.pi / 2] += np.pi - theta[theta > np.pi / 2] -= np.pi + # Compute the matrix Theta of angles between each pair of points + theta = np.arctan2(dY, dX, dtype=np.float32) - # Compute the matrix of stretching factors for each pair of points - stretch_mat = 1 + (stretch - 1.) * np.abs(np.sin(alpha - theta)) + stretch_mat = calculate_stretch_mat(theta, D) + else: + start = 0 + # x and y sizes are the same + stretch_mat = np.empty((len(x), len(y)), dtype=np.float32) + for D_chunk in pairwise_distances_chunked( + points, working_memory=working_memory): + chunk_size = D_chunk.shape[0] + dX = x_array[:, start: start + chunk_size].T - x_array + dY = y_array[:, start: start + chunk_size].T - y_array + + theta_chunk = np.arctan2( + dY, dX, out=stretch_mat[start: start + chunk_size, :]) + + # stretch_mat (theta_chunk) is updated in-place here + calculate_stretch_mat(theta_chunk, D_chunk) + + start += chunk_size # Return the stretched distance matrix - return D * stretch_mat + return stretch_mat def _interpolate_signals(signals, sampling_times, verbose=False): @@ -429,12 +456,82 @@ def _interpolate_signals(signals, sampling_times, verbose=False): return interpolated_signal -class _JSFUniformOrderStat3D(object): - def __init__(self, n, d, precision='double', verbose=False, - cuda_threads=64, cuda_cwr_loops=32): +class _GPUBackend: + """ + Parameters + ---------- + max_chunk_size: int or None, optional + Defines the maximum chunk size used in the `_split_axis` function. The + users typically don't need to set this parameter manually - it's used + to simulate scenarios when the input matrix is so large that it cannot + fit into GPU memory. Setting this parameter manually can resolve GPU + memory errors in case automatic parameters adjustment fails. + + Notes + ----- + 1. PyOpenCL backend takes some time to compile the kernel for the first + time - the caching will affect your benchmarks unless you run each + program twice. + 2. Pinned Host Memory. + Host (CPU) data allocations are pageable by default. The GPU cannot + access data directly from pageable host memory, so when a data transfer + from pageable host memory to device memory is invoked, the CUDA driver + must first allocate a temporary page-locked, or "pinned", host array, + copy the host data to the pinned array, and then transfer the data from + the pinned array to device memory, as illustrated at + https://developer.nvidia.com/blog/how-optimize-data-transfers-cuda-cc/ + Same for OpenCL. Therefore, Python memory analyzers show increments in + the used RAM each time an OpenCL/CUDA buffer is created. As with any + Python objects, PyOpenCL and PyCUDA clean up and free allocated memory + automatically when garbage collection is executed. + """ + def __init__(self, max_chunk_size=None): + self.max_chunk_size = max_chunk_size + + def _choose_backend(self): + # If CUDA is detected, always use CUDA. + # If OpenCL is detected, don't use it by default to avoid the system + # becoming unresponsive until the program terminates. + use_cuda = int(os.getenv("ELEPHANT_USE_CUDA", '1')) + use_opencl = int(os.getenv("ELEPHANT_USE_OPENCL", '1')) + cuda_detected = get_cuda_capability_major() != 0 + if use_cuda and cuda_detected: + return self.pycuda + if use_opencl: + return self.pyopencl + return self.cpu + + def _split_axis(self, chunk_size, axis_size, min_chunk_size=None): + chunk_size = min(chunk_size, axis_size) + if self.max_chunk_size is not None: + chunk_size = min(chunk_size, self.max_chunk_size) + if min_chunk_size is not None and chunk_size < min_chunk_size: + raise ValueError(f"[GPU not enough memory] Impossible to split " + f"the array into chunks of size at least " + f"{min_chunk_size} to fit into GPU memory") + n_chunks = math.ceil(axis_size / chunk_size) + chunk_size = math.ceil(axis_size / n_chunks) # align in size + if min_chunk_size is not None: + chunk_size = max(chunk_size, min_chunk_size) + split_idx = list(range(0, axis_size, chunk_size)) + last_id = split_idx[-1] + last_size = axis_size - last_id # last is the smallest + split_idx = list(zip(split_idx[:-1], split_idx[1:])) + if min_chunk_size is not None and last_size < min_chunk_size: + # Overlap the last chunk with the previous. + # The overlapped part (intersection) will be computed twice. + last_id = axis_size - min_chunk_size + split_idx.append((last_id, axis_size)) + return chunk_size, split_idx + + +class _JSFUniformOrderStat3D(_GPUBackend): + def __init__(self, n, d, precision='float', verbose=False, + cuda_threads=64, cuda_cwr_loops=32, tolerance=1e-5, + max_chunk_size=None): + super().__init__(max_chunk_size=max_chunk_size) if d > n: - raise ValueError("d ({d}) must be less or equal n ({n})".format( - d=d, n=n)) + raise ValueError(f"d ({d}) must be less or equal n ({n})") self.n = n self.d = d self.precision = precision @@ -442,6 +539,9 @@ def __init__(self, n, d, precision='double', verbose=False, self.cuda_threads = cuda_threads self.cuda_cwr_loops = cuda_cwr_loops self.map_iterations = self._create_iteration_table() + bits = 32 if precision == "float" else 64 + self.dtype = np.dtype(f"float{bits}") + self.tolerance = tolerance @property def num_iterations(self): @@ -465,20 +565,6 @@ def _create_iteration_table(self): map_iterations = np.vstack(map_iterations) return map_iterations - def _next_sequence_sorted(self, iteration): - # an alternative implementation to naive for-loop iteration when the - # MPI size is large. However, it's not clear under which circumstances, - # if any, there is a benefit. That's why this function is not used. - sequence_sorted = [] - element = self.n - 1 - for row in range(self.d - 1, -1, -1): - map_row = self.map_iterations[row] - while element > row and iteration < map_row[element]: - element -= 1 - iteration -= map_row[element] - sequence_sorted.append(element + 1) - return tuple(sequence_sorted) - def _combinations_with_replacement(self): # Generate sequences of {a_i} such that # a_0 >= a_1 >= ... >= a_(d-1) and @@ -591,40 +677,244 @@ def cpu(self, log_du): return P_total - def _compile_cuda_template(self, u_length): + def _compile_template(self, template_name, **kwargs): from jinja2 import Template - cu_template_path = os.path.join( - os.path.dirname(os.path.abspath(__file__)), "asset.template.cu") - with open(cu_template_path) as f: - cu_template = Template(f.read()) + cu_template_path = Path(__file__).parent / template_name + cu_template = Template(cu_template_path.read_text()) asset_cu = cu_template.render( - ASSET_DEBUG=int(self.verbose), precision=self.precision, - N_THREADS=self.cuda_threads, CWR_LOOPS=self.cuda_cwr_loops, - L=u_length, N=self.n, D=self.d) + N=self.n, D=self.d, **kwargs) return asset_cu - def cuda(self, log_du): - asset_cu = self._compile_cuda_template(u_length=log_du.shape[0]) + def pyopencl(self, log_du, device_id=0): + import pyopencl as cl + import pyopencl.array as cl_array + + self._check_input(log_du) + + it_todo = self.num_iterations + u_length = log_du.shape[0] + + context = cl.create_some_context(interactive=False) + if self.verbose: + print("Available OpenCL devices:\n", context.devices) + device = context.devices[device_id] + + # A queue bounded to the device + queue = cl.CommandQueue(context) + + max_l_block = device.local_mem_size // ( + self.dtype.itemsize * (self.d + 2)) + n_threads = min(self.cuda_threads, max_l_block, + device.max_work_group_size) + if n_threads > 32: + # It's more efficient to make the number of threads + # a multiple of the warp size (32). + n_threads -= n_threads % 32 + + iteration_table_str = ", ".join(f"{val}LU" for val in + self.map_iterations.flatten()) + iteration_table_str = "{%s}" % iteration_table_str + + log_factorial = np.r_[0, np.cumsum(np.log(range(1, self.n + 1)))] + logK = log_factorial[-1] + log_factorial_str = ", ".join(f"{val:.10f}" for val in log_factorial) + log_factorial_str = "{%s}" % log_factorial_str + atomic_int = 'int' if self.precision == 'float' else 'long' + + # GPU_MAX_HEAP_SIZE OpenCL flag is set to 2 Gb (1 << 31) by default + mem_avail = min(device.max_mem_alloc_size, device.global_mem_size, + 1 << 31) + # 4 * (D + 1) * size + 8 * size == mem_avail + chunk_size = mem_avail // (4 * log_du.shape[1] + self.dtype.itemsize) + chunk_size, split_idx = self._split_axis(chunk_size=chunk_size, + axis_size=u_length) + + P_total = np.empty(u_length, dtype=self.dtype) + P_total_gpu = cl_array.Array(queue, shape=chunk_size, dtype=self.dtype) + + for i_start, i_end in split_idx: + log_du_gpu = cl_array.to_device(queue, log_du[i_start: i_end], + async_=True) + P_total_gpu.fill(0, queue=queue) + chunk_size = i_end - i_start + l_block = min(n_threads, chunk_size) + l_num_blocks = math.ceil(chunk_size / l_block) + grid_size = math.ceil(it_todo / (n_threads * self.cuda_cwr_loops)) + if grid_size > l_num_blocks: + # make grid_size divisible by l_num_blocks + grid_size -= grid_size % l_num_blocks + else: + # grid_size must be at least l_num_blocks + grid_size = l_num_blocks + + if self.verbose: + print(f"[Joint prob. matrix] it_todo={it_todo}, " + f"grid_size={grid_size}, L_BLOCK={l_block}, " + f"N_THREADS={n_threads}") + + # OpenCL defines unsigned long as uint64, therefore we're adding + # the LU suffix, not LLU, which would indicate unsupported uint128 + # data type format. + asset_cl = self._compile_template( + template_name="joint_pmat.cl", + L=f"{chunk_size}LU", + L_BLOCK=l_block, + L_NUM_BLOCKS=l_num_blocks, + ITERATIONS_TODO=f"{it_todo}LU", + logK=f"{logK:.10f}f", + iteration_table=iteration_table_str, + log_factorial=log_factorial_str, + ATOMIC_UINT=f"unsigned {atomic_int}", + ASSET_ENABLE_DOUBLE_SUPPORT=int(self.precision == "double") + ) + + program = cl.Program(context, asset_cl).build() + + # synchronize + cl.enqueue_barrier(queue) + + kernel = program.jsf_uniform_orderstat_3d_kernel + kernel(queue, (grid_size,), (n_threads,), + P_total_gpu.data, log_du_gpu.data, g_times_l=True) + + P_total_gpu[:chunk_size].get(ary=P_total[i_start: i_end]) + + return P_total + + def pycuda(self, log_du): + try: + # PyCuda should not be in requirements-extra because CPU limited + # users won't be able to install Elephant. + import pycuda.autoinit + import pycuda.gpuarray as gpuarray + import pycuda.driver as drv + from pycuda.compiler import SourceModule + except ImportError as err: + raise ImportError( + "Install pycuda with 'pip install pycuda'") from err + + self._check_input(log_du) + + it_todo = self.num_iterations + u_length = log_du.shape[0] + + device = pycuda.autoinit.device + + max_l_block = device.MAX_SHARED_MEMORY_PER_BLOCK // ( + self.dtype.itemsize * (self.d + 2)) + n_threads = min(self.cuda_threads, max_l_block, + device.MAX_THREADS_PER_BLOCK) + if n_threads > device.WARP_SIZE: + # It's more efficient to make the number of threads + # a multiple of the warp size (32). + n_threads -= n_threads % device.WARP_SIZE + + log_factorial = np.r_[0, np.cumsum(np.log(range(1, self.n + 1)))] + log_factorial = log_factorial.astype(self.dtype) + logK = log_factorial[-1] + + free, total = drv.mem_get_info() + # 4 * (D + 1) * size + 8 * size == mem_avail + chunk_size = free // (4 * log_du.shape[1] + self.dtype.itemsize) + chunk_size, split_idx = self._split_axis(chunk_size=chunk_size, + axis_size=u_length) + + P_total = np.empty(u_length, dtype=self.dtype) + P_total_gpu = gpuarray.GPUArray(chunk_size, dtype=self.dtype) + log_du_gpu = drv.mem_alloc(4 * chunk_size * log_du.shape[1]) + + for i_start, i_end in split_idx: + drv.memcpy_htod_async(dest=log_du_gpu, src=log_du[i_start: i_end]) + P_total_gpu.fill(0) + chunk_size = i_end - i_start + l_block = min(n_threads, chunk_size) + l_num_blocks = math.ceil(chunk_size / l_block) + grid_size = math.ceil(it_todo / (n_threads * self.cuda_cwr_loops)) + grid_size = min(grid_size, device.MAX_GRID_DIM_X) + if grid_size > l_num_blocks: + # make grid_size divisible by l_num_blocks + grid_size -= grid_size % l_num_blocks + else: + # grid_size must be at least l_num_blocks + grid_size = l_num_blocks + + if self.verbose: + print(f"[Joint prob. matrix] it_todo={it_todo}, " + f"grid_size={grid_size}, L_BLOCK={l_block}, " + f"N_THREADS={n_threads}") + + asset_cu = self._compile_template( + template_name="joint_pmat.cu", + L=f"{chunk_size}LLU", + L_BLOCK=l_block, + L_NUM_BLOCKS=l_num_blocks, + ITERATIONS_TODO=f"{it_todo}LLU", + logK=f"{logK:.10f}f", + ) + + module = SourceModule(asset_cu) + + iteration_table_gpu, _ = module.get_global("iteration_table") + iteration_table = self.map_iterations.astype(np.uint64) + drv.memcpy_htod(iteration_table_gpu, iteration_table) + + log_factorial_gpu, _ = module.get_global("log_factorial") + drv.memcpy_htod(log_factorial_gpu, log_factorial) + + drv.Context.synchronize() + + kernel = module.get_function("jsf_uniform_orderstat_3d_kernel") + kernel(P_total_gpu.gpudata, log_du_gpu, grid=(grid_size, 1), + block=(n_threads, 1, 1)) + + P_total_gpu[:chunk_size].get(ary=P_total[i_start: i_end]) + + return P_total + + def _cuda(self, log_du): + # Compile a self-contained joint_pmat_old.cu file and run it + # in a terminal. Having this function is useful to debug ASSET CUDA + # application because it's self-contained and the logic is documented. + # Don't use this backend when the 'log_du' arrays are huge because + # of the disk I/O operations. + # A note to developers: remove this backend in half a year once the + # pycuda backend proves to be stable. + + self._check_input(log_du) + + asset_cu = self._compile_template( + template_name="joint_pmat_old.cu", + L=f"{log_du.shape[0]}LLU", + N_THREADS=self.cuda_threads, + ITERATIONS_TODO=f"{self.num_iterations}LLU", + ASSET_DEBUG=int(self.verbose) + ) with tempfile.TemporaryDirectory() as asset_tmp_folder: asset_cu_path = os.path.join(asset_tmp_folder, 'asset.cu') asset_bin_path = os.path.join(asset_tmp_folder, 'asset.o') with open(asset_cu_path, 'w') as f: f.write(asset_cu) # -O3 optimization flag is for the host code only; - # by default, GPU device code is optimized with -O3 - compile_cmd = ['nvcc', '-O3', '-o', asset_bin_path, asset_cu_path] + # by default, GPU device code is optimized with -O3. + # -w to ignore warnings. + compile_cmd = ['nvcc', '-w', '-O3', '-o', asset_bin_path, + asset_cu_path] if self.precision == 'double' and get_cuda_capability_major() >= 6: # atomicAdd(double) requires compute capability 6.x compile_cmd.extend(['-arch', 'sm_60']) compile_status = subprocess.run( compile_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + if self.verbose: + print(compile_status.stdout.decode()) + print(compile_status.stderr.decode(), file=sys.stderr) compile_status.check_returncode() - log_du_path = os.path.join(asset_tmp_folder, "log_du.txt") - P_total_path = os.path.join(asset_tmp_folder, "P_total.txt") - np.savetxt(log_du_path, log_du, fmt="%.10f") + log_du_path = os.path.join(asset_tmp_folder, "log_du.dat") + P_total_path = os.path.join(asset_tmp_folder, "P_total.dat") + with open(log_du_path, 'wb') as f: + log_du.tofile(f) run_status = subprocess.run( [asset_bin_path, log_du_path, P_total_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE) @@ -632,29 +922,35 @@ def cuda(self, log_du): print(run_status.stdout.decode()) print(run_status.stderr.decode(), file=sys.stderr) run_status.check_returncode() - P_total = np.genfromtxt(P_total_path) - - # Large number of floating-point additions can result in values - # outside of the valid range [0, 1]. - P_total = np.clip(P_total, a_min=0., a_max=1.) + with open(P_total_path, 'rb') as f: + P_total = np.fromfile(f, dtype=self.dtype) return P_total - def _choose_backend(self): - if int(os.getenv("ELEPHANT_USE_CUDA", '1')) == 0: - # don't use CUDA - return self.cpu - if not _is_cuda_available(): - return self.cpu - if self.d < 3 or self.n <= 10: - return self.cpu - return self.cuda + def _check_input(self, log_du): + it_todo = self.num_iterations + if it_todo > np.iinfo(np.uint64).max: + raise ValueError(f"it_todo ({it_todo}) is larger than MAX_UINT64." + " Only Python backend is supported.") + # Don't convert log_du to float32 transparently for the user to avoid + # situations when the user accidentally passes an array with float64. + # Doing so wastes memory for nothing. + if log_du.dtype != np.float32: + raise ValueError("'log_du' must be a float32 array") + if log_du.shape[1] != self.d + 1: + raise ValueError(f"log_du.shape[1] ({log_du.shape[1]}) must be " + f"equal to D+1 ({self.d + 1})") def compute(self, u): if u.shape[1] != self.d: raise ValueError("Invalid input data shape axis 1: expected {}, " "got {}".format(self.d, u.shape[1])) - du = np.diff(u, prepend=0, append=1, axis=1) + # A faster and memory efficient implementation of + # du = np.diff(u, prepend=0, append=1, axis=1).astype(np.float32) + du = np.empty((u.shape[0], u.shape[1] + 1), dtype=np.float32) + du[:, 0] = u[:, 0] + np.subtract(u[:, 1:], u[:, :-1], out=du[:, 1:-1]) + np.subtract(1, u[:, -1], out=du[:, -1]) # precompute logarithms # ignore warnings about infinities, see inside the loop: @@ -663,104 +959,311 @@ def compute(self, u): # exp(ln(0)) = exp(-inf) = 0 with warnings.catch_warnings(): warnings.simplefilter('ignore', RuntimeWarning) - log_du = np.log(du) + log_du = np.log(du, out=du) jsf_backend = self._choose_backend() P_total = jsf_backend(log_du) + # Captures non-finite values like NaN, inf + inside = (P_total > -self.tolerance) & (P_total < 1 + self.tolerance) + outside_vals = P_total[~inside] + if len(outside_vals) > 0: + # A watchdog for unexpected results. + warnings.warn(f"{len(outside_vals)}/{P_total.shape[0]} values of " + "the computed joint prob. matrix lie outside of the " + f"valid [0, 1] interval:\n{outside_vals}\nIf you're " + "using PyOpenCL backend, make sure you've disabled " + "GPU Hangcheck as described here https://" + "software.intel.com/content/www/us/en/develop/" + "documentation/get-started-with-intel-oneapi-" + "base-linux/top/before-you-begin.html\n" + "Clipping the output array to 0 and 1.") + P_total = np.clip(P_total, a_min=0., a_max=1., out=P_total) + return P_total -def _pmat_neighbors(mat, filter_shape, n_largest): +class _PMatNeighbors(_GPUBackend): """ - Build the 3D matrix `L` of largest neighbors of elements in a 2D matrix - `mat`. - - For each entry `mat[i, j]`, collects the `n_largest` elements with largest - values around `mat[i, j]`, say `z_i, i=1,2,...,n_largest`, and assigns them - to `L[i, j, :]`. - The zone around `mat[i, j]` where largest neighbors are collected from is - a rectangular area (kernel) of shape `(l, w) = filter_shape` centered - around `mat[i, j]` and aligned along the diagonal. - - If `mat` is symmetric, only the triangle below the diagonal is considered. - Parameters ---------- - mat : np.ndarray - A square matrix of real-valued elements. filter_shape : tuple of int A pair of integers representing the kernel shape `(l, w)`. n_largest : int The number of largest neighbors to collect for each entry in `mat`. + """ - Returns - ------- - lmat : np.ndarray - A matrix of shape `(n_largest, l, w)` containing along the first - dimension `lmat[:, i, j]` the largest neighbors of `mat[i, j]`. + def __init__(self, filter_shape, n_largest, max_chunk_size=None): + super().__init__(max_chunk_size=max_chunk_size) + self.n_largest = n_largest + self.max_chunk_size = max_chunk_size + + filter_size, filter_width = filter_shape + if filter_width >= filter_size: + raise ValueError('filter_shape width must be lower than length') + if not ((filter_width % 2) and (filter_size % 2)): + warnings.warn( + 'The kernel is not centered on the datapoint in whose' + 'calculation it is used. Consider using odd values' + 'for both entries of filter_shape.') + + # Construct the kernel + filt = np.ones((filter_size, filter_size), dtype=bool) + filt = np.triu(filt, -filter_width) + filt = np.tril(filt, filter_width) + if n_largest > len(filt.nonzero()[0]): + raise ValueError(f"Too small filter shape {filter_shape} to " + f"select {n_largest} largest elements.") + + self.filter_kernel = filt + + def _check_input(self, mat): + symmetric = np.all(np.diagonal(mat) == 0.5) + # Check consistent arguments + filter_size = self.filter_kernel.shape[0] + if (symmetric and mat.shape[0] < 2 * filter_size - 1) \ + or (not symmetric and min(mat.shape) < filter_size): + raise ValueError(f"'filter_shape' {self.filter_kernel.shape} is " + f"too large for the input matrix of shape " + f"{mat.shape}") + if mat.dtype != np.float32: + raise ValueError("The input matrix dtype must be float32.") + + def pyopencl(self, mat): + import pyopencl as cl + import pyopencl.array as cl_array + from jinja2 import Template - Raises - ------ - ValueError - If `filter_shape[1]` is not lower than `filter_shape[0]`. + context = cl.create_some_context(interactive=False) + device = context.devices[0] + queue = cl.CommandQueue(context) - Warns - ----- - UserWarning - If both entries in `filter_shape` are not odd values (i.e., the kernel - is not centered on the data point used in the calculation). + # if the matrix is symmetric the diagonal was set to 0.5 + # when computing the probability matrix + symmetric = np.all(np.diagonal(mat) == 0.5) + self._check_input(mat) - """ - l, w = filter_shape - - # if the matrix is symmetric the diagonal was set to 0.5 - # when computing the probability matrix - symmetric = np.all(np.diagonal(mat) == 0.5) - - # Check consistent arguments - if w >= l: - raise ValueError('filter_shape width must be lower than length') - if not ((w % 2) and (l % 2)): - warnings.warn('The kernel is not centered on the datapoint in whose' - 'calculation it is used. Consider using odd values' - 'for both entries of filter_shape.') - - # Construct the kernel - filt = np.ones((l, l), dtype=np.float32) - filt = np.triu(filt, -w) - filt = np.tril(filt, w) - - # Convert mat values to floats, and replaces np.infs with specified input - # values - mat = np.array(mat, dtype=np.float32) - - # Initialize the matrix of d-largest values as a matrix of zeroes - lmat = np.zeros((n_largest, mat.shape[0], mat.shape[1]), dtype=np.float32) - - N_bin_y = mat.shape[0] - N_bin_x = mat.shape[1] - # if the matrix is symmetric do not use kernel positions intersected - # by the diagonal - if symmetric: - bin_range_y = range(l, N_bin_y - l + 1) - else: - bin_range_y = range(N_bin_y - l + 1) - bin_range_x = range(N_bin_x - l + 1) + filt_size = self.filter_kernel.shape[0] # filt is a square matrix + filt_rows, filt_cols = self.filter_kernel.nonzero() + filt_rows = "{%s}" % ", ".join(f"{row}U" for row in filt_rows) + filt_cols = "{%s}" % ", ".join(f"{col}U" for col in filt_cols) + + lmat_padded = np.zeros((mat.shape[0], mat.shape[1], self.n_largest), + dtype=np.float32) + if symmetric: + mat = mat[filt_size:] + lmat = lmat_padded[filt_size + filt_size // 2: -filt_size // 2 + 1] + else: + lmat = lmat_padded[filt_size // 2: -filt_size // 2 + 1] + + # GPU_MAX_HEAP_SIZE OpenCL flag is set to 2 Gb (1 << 31) by default + mem_avail = min(device.max_mem_alloc_size, device.global_mem_size, + 1 << 31) + # 4 * size * n_cols * n_largest + 4 * (size + filt_size) * n_cols + chunk_size = (mem_avail // 4 - filt_size * lmat.shape[1]) // ( + lmat.shape[1] * (self.n_largest + 1)) + chunk_size, split_idx = self._split_axis(chunk_size=chunk_size, + axis_size=lmat.shape[0], + min_chunk_size=filt_size) + + pmat_cl_path = Path(__file__).parent / "pmat_neighbors.cl" + pmat_cl_template = Template(pmat_cl_path.read_text()) + + lmat_gpu = cl_array.Array( + queue, shape=(chunk_size, lmat.shape[1], self.n_largest), + dtype=np.float32 + ) + + for i_start, i_end in split_idx: + mat_gpu = cl_array.to_device(queue, + mat[i_start: i_end + filt_size], + async_=True) + lmat_gpu.fill(0, queue=queue) + chunk_size = i_end - i_start + it_todo = chunk_size * (lmat.shape[1] - filt_size + 1) + + pmat_neighbors_cl = pmat_cl_template.render( + FILT_SIZE=filt_size, + N_LARGEST=self.n_largest, + PMAT_COLS=f"{lmat.shape[1]}LU", + Y_OFFSET=f"{i_start}LU", + NONZERO_SIZE=self.filter_kernel.sum(), + SYMMETRIC=int(symmetric), + filt_rows=filt_rows, + filt_cols=filt_cols + ) + + program = cl.Program(context, pmat_neighbors_cl).build() + + # synchronize + cl.enqueue_barrier(queue) + + kernel = program.pmat_neighbors + # When the grid size is set to the total number of work items to + # execute and the local size is set to None, PyOpenCL chooses the + # number of threads automatically such that the total number of + # work items exactly matches the desired number of iterations. + kernel(queue, (it_todo,), None, lmat_gpu.data, mat_gpu.data) + + lmat_gpu[:chunk_size].get(ary=lmat[i_start: i_end]) + + return lmat_padded + + def pycuda(self, mat): + from jinja2 import Template + try: + # PyCuda should not be in requirements-extra because CPU limited + # users won't be able to install Elephant. + import pycuda.autoinit + import pycuda.gpuarray as gpuarray + import pycuda.driver as drv + from pycuda.compiler import SourceModule + except ImportError as err: + raise ImportError( + "Install pycuda with 'pip install pycuda'") from err + + # if the matrix is symmetric the diagonal was set to 0.5 + # when computing the probability matrix + symmetric = np.all(np.diagonal(mat) == 0.5) + self._check_input(mat) + + device = pycuda.autoinit.device + n_threads = device.MAX_THREADS_PER_BLOCK + + filt_size = self.filter_kernel.shape[0] + filt_rows, filt_cols = self.filter_kernel.nonzero() + + lmat_padded = np.zeros((mat.shape[0], mat.shape[1], self.n_largest), + dtype=np.float32) + if symmetric: + mat = mat[filt_size:] + lmat = lmat_padded[filt_size + filt_size // 2: -filt_size // 2 + 1] + else: + lmat = lmat_padded[filt_size // 2: -filt_size // 2 + 1] + + free, total = drv.mem_get_info() + # 4 * size * n_cols * n_largest + 4 * (size + filt_size) * n_cols + chunk_size = (free // 4 - filt_size * lmat.shape[1]) // ( + lmat.shape[1] * (self.n_largest + 1)) + chunk_size, split_idx = self._split_axis(chunk_size=chunk_size, + axis_size=lmat.shape[0], + min_chunk_size=filt_size) + + pmat_cu_path = Path(__file__).parent / "pmat_neighbors.cu" + pmat_cu_template = Template(pmat_cu_path.read_text()) + + lmat_gpu = gpuarray.GPUArray( + (chunk_size, lmat.shape[1], self.n_largest), dtype=np.float32) + + mat_gpu = drv.mem_alloc(4 * (chunk_size + filt_size) * mat.shape[1]) + + for i_start, i_end in split_idx: + drv.memcpy_htod_async(dest=mat_gpu, + src=mat[i_start: i_end + filt_size]) + lmat_gpu.fill(0) + chunk_size = i_end - i_start + it_todo = chunk_size * (lmat.shape[1] - filt_size + 1) - # compute matrix of largest values - for y in bin_range_y: + pmat_neighbors_cu = pmat_cu_template.render( + FILT_SIZE=filt_size, + N_LARGEST=self.n_largest, + PMAT_COLS=f"{lmat.shape[1]}LLU", + Y_OFFSET=f"{i_start}LLU", + NONZERO_SIZE=self.filter_kernel.sum(), + SYMMETRIC=int(symmetric), + IT_TODO=it_todo, + ) + + module = SourceModule(pmat_neighbors_cu) + + filt_rows_gpu, _ = module.get_global("filt_rows") + drv.memcpy_htod(filt_rows_gpu, filt_rows.astype(np.uint32)) + + filt_cols_gpu, _ = module.get_global("filt_cols") + drv.memcpy_htod(filt_cols_gpu, filt_cols.astype(np.uint32)) + + drv.Context.synchronize() + + grid_size = math.ceil(it_todo / n_threads) + if grid_size > device.MAX_GRID_DIM_X: + raise ValueError("Cannot launch a CUDA kernel with " + f"{grid_size} num. of blocks. Adjust the " + "'max_chunk_size' parameter.") + + kernel = module.get_function("pmat_neighbors") + kernel(lmat_gpu.gpudata, mat_gpu, grid=(grid_size, 1), + block=(n_threads, 1, 1)) + + lmat_gpu[:chunk_size].get(ary=lmat[i_start: i_end]) + + return lmat_padded + + def compute(self, mat): + """ + Build the 3D matrix `L` of largest neighbors of elements in a 2D matrix + `mat`. + + For each entry `mat[i, j]`, collects the `n_largest` elements with + largest values around `mat[i, j]`, say `z_i, i=1,2,...,n_largest`, + and assigns them to `L[i, j, :]`. + The zone around `mat[i, j]` where largest neighbors are collected from + is a rectangular area (kernel) of shape `(l, w) = filter_shape` + centered around `mat[i, j]` and aligned along the diagonal. + + If `mat` is symmetric, only the triangle below the diagonal is + considered. + + Parameters + ---------- + mat : np.ndarray + A square matrix of real-valued elements. + + Returns + ------- + lmat : np.ndarray + A matrix of shape `(l, w, n_largest)` containing along the last + dimension `lmat[i, j, :]` the largest neighbors of `mat[i, j]`. + """ + backend = self._choose_backend() + lmat = backend(mat) + return lmat + + def cpu(self, mat): + # if the matrix is symmetric the diagonal was set to 0.5 + # when computing the probability matrix + symmetric = np.all(np.diagonal(mat) == 0.5) + self._check_input(mat) + + filter_size = self.filter_kernel.shape[0] + + # Initialize the matrix of d-largest values as a matrix of zeroes + lmat = np.zeros((mat.shape[0], mat.shape[1], self.n_largest), + dtype=np.float32) + + N_bin_y = mat.shape[0] + N_bin_x = mat.shape[1] + # if the matrix is symmetric do not use kernel positions intersected + # by the diagonal if symmetric: - # x range depends on y position - bin_range_x = range(y - l + 1) - for x in bin_range_x: - patch = mat[y: y + l, x: x + l] - mskd = np.multiply(filt, patch) - largest_vals = np.sort(mskd, axis=None)[-n_largest:] - lmat[:, y + (l // 2), x + (l // 2)] = largest_vals + bin_range_y = range(filter_size, N_bin_y - filter_size + 1) + else: + bin_range_y = range(N_bin_y - filter_size + 1) + bin_range_x = range(N_bin_x - filter_size + 1) - return lmat + # compute matrix of largest values + for y in bin_range_y: + if symmetric: + # x range depends on y position + bin_range_x = range(y - filter_size + 1) + for x in bin_range_x: + patch = mat[y: y + filter_size, x: x + filter_size] + mskd = patch[self.filter_kernel] + largest_vals = np.sort(mskd)[-self.n_largest:] + lmat[y + (filter_size // 2), x + (filter_size // 2), :] = \ + largest_vals + + return lmat def synchronous_events_intersection(sse1, sse2, intersection='linkwise'): @@ -1644,8 +2147,9 @@ def probability_matrix_analytical(self, imat=None, return pmat def joint_probability_matrix(self, pmat, filter_shape, n_largest, - min_p_value=1e-5, precision='double', - cuda_threads=64, cuda_cwr_loops=32): + min_p_value=1e-5, precision='float', + cuda_threads=64, cuda_cwr_loops=32, + tolerance=1e-5): """ Map a probability matrix `pmat` to a joint probability matrix `jmat`, where `jmat[i, j]` is the joint p-value of the largest neighbors of @@ -1679,25 +2183,40 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, joint significance of itself and its neighbors. Default: 1e-5 precision : {'float', 'double'}, optional - The floating-point precision of the resulting `jmat` matrix. + Single or double floating-point precision for the resulting `jmat` + matrix. * `'float'`: 32 bits; the tolerance error is ``≲1e-3``. * `'double'`: 64 bits; the tolerance error is ``<1e-5``. + Double floating-point precision is typically x4 times slower than + the single floating-point equivalent. Default: 'float' cuda_threads : int, optional - The number of CUDA threads per block (in X axis) between 1 and - 1024 and is used only if CUDA backend is enabled. + [CUDA/OpenCL performance parameter that does not influence the + result.] + The number of CUDA/OpenCL threads per block (in X axis) between 1 + and 1024 and is used only if CUDA or OpenCL backend is enabled. For performance reasons, it should be a multiple of 32. Old GPUs (Tesla K80) perform faster with `cuda_threads` larger than 64 while new series (Tesla T4) with capabilities 6.x and more work best with 32 threads. Default: 64 cuda_cwr_loops : int, optional - CUDA optimization parameter, a positive integer that defines the - number of fast 'combinations_with_replacement' loops to run to - reduce branch divergence. This parameter influences the performance - when the number of iterations is huge (`>1e8`). + [CUDA/OpenCL performance parameter that does not influence the + result.] + A positive integer that defines the number of fast + 'combinations_with_replacement' loops to run to reduce branch + divergence. This parameter influences the performance when the + number of iterations is huge (`>1e8`); in such cases, increase + the value. Default: 32 + tolerance : float, optional + Tolerance is used to catch unexpected behavior of billions of + floating point additions, when the number of iterations is huge + or the data arrays are large. A warning is thrown when the + resulting joint prob. matrix values are outside of the acceptable + range ``[-tolerance, 1.0 + tolerance]``. + Default: 1e-5 Returns ------- @@ -1706,27 +2225,41 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, Notes ----- - By default, if a GPU is detected, CUDA implementations is used for - large arrays. To turn off CUDA features, set the environment flag - `ELEPHANT_USE_CUDA=0` either in python or via the command line: - - ``ELEPHANT_USE_CUDA=0 python /path/to/script`` + 1. By default, if CUDA is detected, CUDA acceleration is used. CUDA + backend is **~X1000** faster than the Python implementation. + To turn off CUDA features, set the environment flag + ``ELEPHANT_USE_CUDA`` to ``0``. Otherwise + 2. If PyOpenCL is installed and detected, PyOpenCL backend is used. + PyOpenCL backend is **~X100** faster than the Python implementation. + To turn off OpenCL features, set the environment flag + ``ELEPHANT_USE_OPENCL`` to ``0``. + + When using PyOpenCL backend, make sure you've disabled GPU Hangcheck + as described in the `Intel GPU developers documentation + `_. Do it with caution - using your built-in + Intel graphics card to perform computations may make the system + unresponsive until the compute program terminates. """ l, w = filter_shape # Find for each P_ij in the probability matrix its neighbors and # maximize them by the maximum value 1-p_value_min - pmat_neighb = _pmat_neighbors( - pmat, filter_shape=filter_shape, n_largest=n_largest) + pmat = np.asarray(pmat, dtype=np.float32) + pmat_neighb_obj = _PMatNeighbors(filter_shape=filter_shape, + n_largest=n_largest) + pmat_neighb = pmat_neighb_obj.compute(pmat) - pmat_neighb = np.minimum(pmat_neighb, 1. - min_p_value) + pmat_neighb = np.minimum(pmat_neighb, 1. - min_p_value, + out=pmat_neighb) # in order to avoid doing the same calculation multiple times: # find all unique sets of values in pmat_neighb # and store the corresponding indices # flatten the second and third dimension in order to use np.unique - pmat_neighb = pmat_neighb.reshape(n_largest, pmat.size).T + pmat_neighb = pmat_neighb.reshape(pmat.size, n_largest) pmat_neighb, pmat_neighb_indices = np.unique(pmat_neighb, axis=0, return_inverse=True) @@ -1737,7 +2270,8 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, precision=precision, verbose=self.verbose, cuda_threads=cuda_threads, - cuda_cwr_loops=cuda_cwr_loops) + cuda_cwr_loops=cuda_cwr_loops, + tolerance=tolerance) jpvmat = jsf.compute(u=pmat_neighb) # restore the original shape using the stored indices @@ -1802,7 +2336,7 @@ def mask_matrices(matrices, thresholds): @staticmethod def cluster_matrix_entries(mask_matrix, max_distance, min_neighbors, - stretch): + stretch, working_memory=None): r""" Given a matrix `mask_matrix`, replaces its positive elements with integers representing different cluster IDs. Each cluster comprises @@ -1854,6 +2388,14 @@ def cluster_matrix_entries(mask_matrix, max_distance, min_neighbors, stretching increases from 1 to `stretch` as the direction of the two elements moves from the 45 to the 135 degree direction. `stretch` must be greater than 1. + working_memory : int or None, optional + The sought maximum memory in MiB for temporary distance matrix + chunks. When None (default), no chunking is performed. This + parameter is passed directly to + ``sklearn.metrics.pairwise_distances_chunked`` function and it + has no influence on the outcome matrix. Instead, it control the + memory VS speed trade-off. + Default: None Returns ------- @@ -1881,8 +2423,14 @@ def cluster_matrix_entries(mask_matrix, max_distance, min_neighbors, # Compute the matrix D[i, j] of euclidean distances between pixels i # and j - D = _stretched_metric_2d( - xpos_sgnf, ypos_sgnf, stretch=stretch, ref_angle=45) + try: + D = _stretched_metric_2d( + xpos_sgnf, ypos_sgnf, stretch=stretch, ref_angle=45, + working_memory=working_memory + ) + except MemoryError as err: + raise MemoryError("Set 'working_memory=100' or another value to " + "chunk the data") from err # Cluster positions of significant pixels via dbscan core_samples, config = dbscan( diff --git a/elephant/asset/joint_pmat.cl b/elephant/asset/joint_pmat.cl new file mode 100644 index 000000000..201c8b187 --- /dev/null +++ b/elephant/asset/joint_pmat.cl @@ -0,0 +1,198 @@ +// Enable support for double floating-point precision, if needed. +#if {{ASSET_ENABLE_DOUBLE_SUPPORT}} + #pragma OPENCL EXTENSION cl_khr_fp64: enable + #pragma OPENCL EXTENSION cl_khr_int64_base_atomics: enable +#endif + +#define L {{L}} +#define N {{N}} +#define D {{D}} + +#define L_BLOCK {{L_BLOCK}} +#define L_NUM_BLOCKS {{L_NUM_BLOCKS}} +#define ITERATIONS_TODO {{ITERATIONS_TODO}} +#define logK {{logK}} + +#if D > N +#error "D must be less or equal N" +#endif + +/** + * OpenCL spec. defines unsigned long as uint64. + */ +#define ULL unsigned long + +/** + * Convert float or double to uint32 or uint64 accordingly. + */ +#define ATOMIC_UINT {{ATOMIC_UINT}} + +/** + * To reduce branch divergence in 'next_sequence_sorted' function + * within a warp (threads in a warp take different branches), + * each thread runs CWR_LOOPS of 'combinations_with_replacement'. + */ +#define CWR_LOOPS {{CWR_LOOPS}} + +typedef {{precision}} asset_float; + +__constant asset_float log_factorial[] = {{log_factorial}}; +__constant ULL iteration_table[] = {{iteration_table}}; + +void atomicAdd_global(__global asset_float* source, const asset_float operand) +{ + union { + ATOMIC_UINT intVal; + asset_float floatVal; + } newVal; + union { + ATOMIC_UINT intVal; + asset_float floatVal; + } prevVal; + + do { + prevVal.floatVal = *source; + newVal.floatVal = prevVal.floatVal + operand; + } while (atom_cmpxchg((volatile global ATOMIC_UINT *)source, prevVal.intVal, newVal.intVal) != prevVal.intVal); +} + +void atomicAdd_local(__local asset_float* source, const asset_float operand) +{ + union { + ATOMIC_UINT intVal; + asset_float floatVal; + } newVal; + + union { + ATOMIC_UINT intVal; + asset_float floatVal; + } prevVal; + + do { + prevVal.floatVal = *source; + newVal.floatVal = prevVal.floatVal + operand; + } while (atom_cmpxchg((volatile local ATOMIC_UINT *)source, prevVal.intVal, newVal.intVal) != prevVal.intVal); +} + + +/** + * Builds the next sequence_sorted, given the absolute iteration ID. + * The time complexity is O(N+D), not O(N*D). + * + * @param sequence_sorted the output sequence_sorted array of size D + * @param iteration the global iteration ID + */ +void next_sequence_sorted(int *sequence_sorted, ULL iteration) { + int row, element = N - 1; + for (row = D - 1; row >= 0; row--) { + while (element > row && iteration < iteration_table[row * N + element]) { + element--; + } + iteration -= iteration_table[row * N + element]; + sequence_sorted[D - 1 - row] = element + 1; + } +} + + +/** + * Set 'sequence_sorted' to the next valid sequence of indices in-place. + */ +void combinations_with_replacement(int *sequence_sorted) { + int increment_id = D - 1; + while (increment_id > 0 && sequence_sorted[increment_id - 1] == sequence_sorted[increment_id]) { + sequence_sorted[increment_id] = D - increment_id; + increment_id--; + } + sequence_sorted[increment_id]++; +} + + +/** + * CUDA kernel that computes P_total - the joint survival probabilities matrix. + * + * @param P_out P_total output array of size L + * @param log_du_device input log_du flattened matrix of size L*(D+1) + */ +__kernel void jsf_uniform_orderstat_3d_kernel(__global asset_float *P_out, __global const float *log_du_device) { + unsigned int i; + ULL row; + + const int threadIdx_x = get_local_id(0); + const int blockDim_x = get_local_size(0); + + // blockIdx_x and gridDim_x are upperbounded by 2^31 - 1. + const ULL blockIdx_x = get_group_id(0); + const ULL gridDim_x = get_num_groups(0); + + // the row shift of log_du and P_total in the number of elements, between 0 and L + const ULL l_shift = (blockIdx_x % L_NUM_BLOCKS) * L_BLOCK; + + // account for the last block width that can be less than L_BLOCK + const ULL block_width = (L - l_shift < L_BLOCK) ? (L - l_shift) : L_BLOCK; + + __local asset_float P_total[L_BLOCK]; + __local float log_du[L_BLOCK * (D + 1)]; + + for (row = threadIdx_x; row < block_width; row += blockDim_x) { + P_total[row] = 0; + for (i = 0; i <= D; i++) { + log_du[row * (D + 1) + i] = log_du_device[(row + l_shift) * (D + 1) + i]; + } + } + + barrier(CLK_LOCAL_MEM_FENCE); + + int di[D + 1]; + int sequence_sorted[D]; + asset_float P_thread[L_BLOCK]; + for (row = 0; row < block_width; row++) { + P_thread[row] = 0; + } + + const ULL burnout = (blockIdx_x / L_NUM_BLOCKS) * blockDim_x * CWR_LOOPS + threadIdx_x * CWR_LOOPS; + const ULL stride = (gridDim_x / L_NUM_BLOCKS) * blockDim_x * CWR_LOOPS; + + ULL iteration, cwr_loop; + for (iteration = burnout; iteration < ITERATIONS_TODO; iteration += stride) { + next_sequence_sorted(sequence_sorted, iteration); + + for (cwr_loop = 0; (cwr_loop < CWR_LOOPS) && (sequence_sorted[0] != N + 1); cwr_loop++) { + int prev = N; + for (i = 0; i < D; i++) { + di[i] = prev - sequence_sorted[i]; + prev = sequence_sorted[i]; + } + di[D] = sequence_sorted[D - 1]; + + asset_float sum_log_di_factorial = 0.f; + for (i = 0; i <= D; i++) { + sum_log_di_factorial += log_factorial[di[i]]; + } + + asset_float colsum; + const asset_float colsum_base = logK - sum_log_di_factorial; + for (row = 0; row < block_width; row++) { + colsum = colsum_base; + for (i = 0; i <= D; i++) { + if (di[i] != 0) { + colsum += di[i] * log_du[row * (D + 1) + i]; + } + } + P_thread[row] += exp(colsum); + } + + combinations_with_replacement(sequence_sorted); + } + } + + for (row = threadIdx_x; row < block_width + threadIdx_x; row++) { + // Reduce atomicAdd conflicts by adding threadIdx_x to each row + atomicAdd_local(P_total + row % block_width, P_thread[row % block_width]); + } + + barrier(CLK_LOCAL_MEM_FENCE); + + for (row = threadIdx_x; row < block_width; row += blockDim_x) { + atomicAdd_global(P_out + row + l_shift, P_total[row]); + } +} diff --git a/elephant/asset/joint_pmat.cu b/elephant/asset/joint_pmat.cu new file mode 100644 index 000000000..90f85b9fd --- /dev/null +++ b/elephant/asset/joint_pmat.cu @@ -0,0 +1,169 @@ +#define L {{L}} +#define N {{N}} +#define D {{D}} + +#define L_BLOCK {{L_BLOCK}} +#define L_NUM_BLOCKS {{L_NUM_BLOCKS}} +#define ITERATIONS_TODO {{ITERATIONS_TODO}} +#define logK {{logK}} + +#if D > N +#error "D must be less or equal N" +#endif + +#define ULL unsigned long long + +/** + * To reduce branch divergence in 'next_sequence_sorted' function + * within a warp (threads in a warp take different branches), + * each thread runs CWR_LOOPS of 'combinations_with_replacement'. + */ +#define CWR_LOOPS {{CWR_LOOPS}} + +typedef {{precision}} asset_float; + +__constant__ asset_float log_factorial[N + 1]; +__constant__ ULL iteration_table[D][N]; /* Maps the iteration ID to the entries + of a sequence_sorted array */ + +/** + * Compute capabilities lower than 6.0 don't have hardware support for + * double-precision atomicAdd. This software implementation is taken from + * https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html + */ +#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 600 +__device__ double atomicAdd(double* address, double val) +{ + ULL* address_as_ull = (ULL*)address; + ULL old = *address_as_ull, assumed; + + do { + assumed = old; + old = atomicCAS(address_as_ull, assumed, + __double_as_longlong(val + + __longlong_as_double(assumed))); + + // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN) + } while (assumed != old); + + return __longlong_as_double(old); +} +#endif + + +/** + * Builds the next sequence_sorted, given the absolute iteration ID. + * The time complexity is O(N+D), not O(N*D). + * + * @param sequence_sorted the output sequence_sorted array of size D + * @param iteration the global iteration ID + */ +__device__ void next_sequence_sorted(int *sequence_sorted, ULL iteration) { + int row, element = N - 1; + for (row = D - 1; row >= 0; row--) { + while (element > row && iteration < iteration_table[row][element]) { + element--; + } + iteration -= iteration_table[row][element]; + sequence_sorted[D - 1 - row] = element + 1; + } +} + + +/** + * Set 'sequence_sorted' to the next valid sequence of indices in-place. + */ +__device__ void combinations_with_replacement(int *sequence_sorted) { + int increment_id = D - 1; + while (increment_id > 0 && sequence_sorted[increment_id - 1] == sequence_sorted[increment_id]) { + sequence_sorted[increment_id] = D - increment_id; + increment_id--; + } + sequence_sorted[increment_id]++; +} + + +/** + * CUDA kernel that computes P_total - the joint survival probabilities matrix. + * + * @param P_out P_total output array of size L + * @param log_du_device input log_du flattened matrix of size L*(D+1) + */ +__global__ void jsf_uniform_orderstat_3d_kernel(asset_float *P_out, const float *log_du_device) { + unsigned int i; + ULL row; + + // the row shift of log_du and P_total in the number of elements, between 0 and L + const ULL l_shift = (blockIdx.x % L_NUM_BLOCKS) * L_BLOCK; + + // account for the last block width that can be less than L_BLOCK + const ULL block_width = (L - l_shift < L_BLOCK) ? (L - l_shift) : L_BLOCK; + + __shared__ asset_float P_total[L_BLOCK]; + __shared__ float log_du[L_BLOCK * (D + 1)]; + + for (row = threadIdx.x; row < block_width; row += blockDim.x) { + P_total[row] = 0; + for (i = 0; i <= D; i++) { + log_du[row * (D + 1) + i] = log_du_device[(row + l_shift) * (D + 1) + i]; + } + } + + __syncthreads(); + + int di[D + 1]; + int sequence_sorted[D]; + asset_float P_thread[L_BLOCK]; + for (row = 0; row < block_width; row++) { + P_thread[row] = 0; + } + + const ULL burnout = (blockIdx.x / L_NUM_BLOCKS) * blockDim.x * CWR_LOOPS + threadIdx.x * CWR_LOOPS; + const ULL stride = (gridDim.x / L_NUM_BLOCKS) * blockDim.x * CWR_LOOPS; + + ULL iteration, cwr_loop; + for (iteration = burnout; iteration < ITERATIONS_TODO; iteration += stride) { + next_sequence_sorted(sequence_sorted, iteration); + + for (cwr_loop = 0; (cwr_loop < CWR_LOOPS) && (sequence_sorted[0] != N + 1); cwr_loop++) { + int prev = N; + for (i = 0; i < D; i++) { + di[i] = prev - sequence_sorted[i]; + prev = sequence_sorted[i]; + } + di[D] = sequence_sorted[D - 1]; + + asset_float sum_log_di_factorial = 0.f; + for (i = 0; i <= D; i++) { + sum_log_di_factorial += log_factorial[di[i]]; + } + + asset_float colsum; + const asset_float colsum_base = logK - sum_log_di_factorial; + const float *log_du_row = log_du; + for (row = 0; row < block_width; row++) { + colsum = colsum_base; + for (i = 0; i <= D; i++) { + if (di[i] != 0) { + colsum += di[i] * log_du_row[i]; + } + } + P_thread[row] += exp(colsum); + log_du_row += D + 1; + } + + combinations_with_replacement(sequence_sorted); + } + } + + for (row = threadIdx.x; row < block_width + threadIdx.x; row++) { + // Reduce atomicAdd conflicts by adding threadIdx.x to each row + atomicAdd(P_total + row % block_width, P_thread[row % block_width]); + } + + __syncthreads(); + + for (row = threadIdx.x; row < block_width; row += blockDim.x) { + atomicAdd(P_out + row + l_shift, P_total[row]); + } +} diff --git a/elephant/asset/asset.template.cu b/elephant/asset/joint_pmat_old.cu similarity index 70% rename from elephant/asset/asset.template.cu rename to elephant/asset/joint_pmat_old.cu index c33926675..838c7b110 100644 --- a/elephant/asset/asset.template.cu +++ b/elephant/asset/joint_pmat_old.cu @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -17,7 +18,11 @@ #define N {{N}} #define D {{D}} -#define min_macros(a,b) (a < b ? a : b) +#if D > N +#error "D must be less or equal N" +#endif + +#define min_macros(a,b) ((a) < (b) ? (a) : (b)) #define ASSET_DEBUG {{ASSET_DEBUG}} #define ULL unsigned long long @@ -45,7 +50,7 @@ typedef {{precision}} asset_float; __constant__ asset_float log_factorial[N + 1]; __constant__ asset_float logK; __constant__ ULL ITERATIONS_TODO; -__constant__ unsigned int L_BLOCK; +__constant__ ULL L_BLOCK; __constant__ ULL L_NUM_BLOCKS; __constant__ ULL iteration_table[D][N]; /* Maps the iteration ID to the entries of a sequence_sorted array */ @@ -74,6 +79,16 @@ __device__ double atomicAdd(double* address, double val) } #endif +#define gpuErrchk(ans) { gpuAssert((ans), __FILE__, __LINE__); } +inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort=true) +{ + if (code != cudaSuccess) + { + fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line); + if (abort) exit(code); + } +} + /** * Builds the next sequence_sorted, given the absolute iteration ID. @@ -113,14 +128,15 @@ __device__ void combinations_with_replacement(int *sequence_sorted) { * @param P_out P_total output array of size L * @param log_du_device input log_du flattened matrix of size L*(D+1) */ -__global__ void jsf_uniform_orderstat_3d_kernel(asset_float *P_out, float *log_du_device) { - unsigned int i, row; +__global__ void jsf_uniform_orderstat_3d_kernel(asset_float *P_out, const float *log_du_device) { + unsigned int i; + ULL row; // the row shift of log_du and P_total in the number of elements, between 0 and L - const unsigned int l_shift = (blockIdx.x % L_NUM_BLOCKS) * L_BLOCK; + const ULL l_shift = (blockIdx.x % L_NUM_BLOCKS) * L_BLOCK; // account for the last block width that can be less than L_BLOCK - const unsigned int block_width = (L - l_shift < L_BLOCK) ? (L - l_shift) : L_BLOCK; + const ULL block_width = (L - l_shift < L_BLOCK) ? (L - l_shift) : L_BLOCK; extern __shared__ float shared_mem[]; asset_float *P_total = (asset_float*) shared_mem; // L_BLOCK floats @@ -222,9 +238,9 @@ ULL create_iteration_table() { // values greater than ULONG_MAX are not supported by CUDA assert(it_todo_double <= ULONG_MAX); - cudaMemcpyToSymbol(iteration_table, m, sizeof(ULL) * D * N); + gpuErrchk( cudaMemcpyToSymbol(iteration_table, m, sizeof(ULL) * D * N) ); - cudaMemcpyToSymbol((const void*) &ITERATIONS_TODO, (const void*) &it_todo, sizeof(ULL)); + gpuErrchk( cudaMemcpyToSymbol((const void*) &ITERATIONS_TODO, (const void*) &it_todo, sizeof(ULL)) ); free(m); @@ -251,9 +267,9 @@ void print_constants() { cudaMemcpyFromSymbol((void*)&it_todo_host, (const void*)&ITERATIONS_TODO, sizeof(ULL)); printf(">>> ITERATIONS_TODO = %llu\n", it_todo_host); - unsigned int l_block; - cudaMemcpyFromSymbol((void*)&l_block, (const void*)&L_BLOCK, sizeof(l_block)); - printf(">>> L_BLOCK = %u\n", l_block); + ULL l_block; + cudaMemcpyFromSymbol((void*)&l_block, (const void*)&L_BLOCK, sizeof(ULL)); + printf(">>> L_BLOCK = %llu\n", l_block); ULL l_num_blocks; cudaMemcpyFromSymbol((void*)&l_num_blocks, (const void*)&L_NUM_BLOCKS, sizeof(ULL)); @@ -280,7 +296,38 @@ void print_constants() { * @param P_total_host a pointer to P_total array to be calculated * @param log_du_host input flattened L*(D+1) matrix of log_du values */ -void jsf_uniform_orderstat_3d(asset_float *P_total_host, const float *log_du_host) { +void jsf_uniform_orderstat_3d(asset_float *P_total_host, FILE *log_du_file) { + float *log_du_device; + gpuErrchk( cudaMalloc((void**)&log_du_device, sizeof(float) * L * (D + 1)) ); + + float *log_du_host; + +#if L * (D + 1) < 100000000LLU + // For arrays of size <100 Mb, allocate host memory for log_du + log_du_host = (float*) malloc(sizeof(float) * L * (D + 1)); + fread(log_du_host, sizeof(float), L * (D + 1), log_du_file); + gpuErrchk( cudaMemcpyAsync(log_du_device, log_du_host, sizeof(float) * L * (D + 1), cudaMemcpyHostToDevice) ); +#else + // Use P_total buffer to read log_du and copy batches to a GPU card + log_du_host = (float*) P_total_host; + ULL col; + for (col = 0; col <= D; col++) { + fread(log_du_host, sizeof(float), L, log_du_file); + // Wait till the copy finishes before filling the buffer with a next chunk. + gpuErrchk( cudaMemcpy(log_du_device + col * L, log_du_host, sizeof(float) * L, cudaMemcpyHostToDevice) ); + } +#endif + + fclose(log_du_file); + + asset_float *P_total_device; + + // Initialize P_total_device with zeros. + // Note that values other than 0x00 or 0xFF (NaN) won't work + // with cudaMemset when the data type is float or double. + gpuErrchk( cudaMalloc((void**)&P_total_device, sizeof(asset_float) * L) ); + gpuErrchk( cudaMemsetAsync(P_total_device, 0, sizeof(asset_float) * L) ); + ULL it_todo = create_iteration_table(); asset_float logK_host = 0.f; @@ -292,36 +339,31 @@ void jsf_uniform_orderstat_3d(asset_float *P_total_host, const float *log_du_hos log_factorial_host[i] = logK_host; } - cudaMemcpyToSymbol((const void*) &logK, (const void*) &logK_host, sizeof(asset_float)); - cudaMemcpyToSymbol(log_factorial, log_factorial_host, sizeof(asset_float) * (N + 1)); + gpuErrchk( cudaMemcpyToSymbol((const void*) &logK, (const void*) &logK_host, sizeof(asset_float)) ); + gpuErrchk( cudaMemcpyToSymbol(log_factorial, log_factorial_host, sizeof(asset_float) * (N + 1)) ); cudaDeviceProp device_prop; - cudaGetDeviceProperties(&device_prop, 0); - const unsigned int max_l_block = device_prop.sharedMemPerBlock / (sizeof(asset_float) * (D + 2)); + gpuErrchk( cudaGetDeviceProperties(&device_prop, 0) ); + const ULL max_l_block = device_prop.sharedMemPerBlock / (sizeof(asset_float) * (D + 2)); /** - * It's important to match the width (tile) of - * a block with N_THREADS, if N_THREADS < L. + * It's not necessary to match N_THREADS with the final L_BLOCK. Alternatively, + * the desired L_BLOCK can be another parameter specified by the user. But + * the optimal L_BLOCK on average matches N_THREADS, therefore, to avoid + * the user thinking too much, we take care of the headache by setting + * L_BLOCK = N_THREADS. */ - unsigned int n_threads = min_macros(N_THREADS, min_macros(max_l_block, device_prop.maxThreadsPerBlock)); + unsigned int n_threads = (unsigned int) min_macros(N_THREADS, min_macros(max_l_block, device_prop.maxThreadsPerBlock)); if (n_threads > device_prop.warpSize) { // It's more efficient to make the number of threads // a multiple of the warp size (32). n_threads -= n_threads % device_prop.warpSize; } - const unsigned int l_block = min_macros(n_threads, L); - cudaMemcpyToSymbol((const void*) &L_BLOCK, (const void*) &l_block, sizeof(l_block)); + const ULL l_block = min_macros(n_threads, L); + gpuErrchk( cudaMemcpyToSymbol((const void*) &L_BLOCK, (const void*) &l_block, sizeof(ULL)) ); const ULL l_num_blocks = (ULL) ceil(L * 1.f / l_block); - cudaMemcpyToSymbol((const void*) &L_NUM_BLOCKS, (const void*) &l_num_blocks, sizeof(ULL)); - - asset_float *P_total_device; - - // Initialize P_total_device with zeros. - // Note that values other than 0x00 or 0xFF (NaN) won't work - // with cudaMemset when the data type is float or double. - cudaMalloc((void**)&P_total_device, sizeof(asset_float) * L); - cudaMemset(P_total_device, 0, sizeof(asset_float) * L); + gpuErrchk( cudaMemcpyToSymbol((const void*) &L_NUM_BLOCKS, (const void*) &l_num_blocks, sizeof(ULL)) ); ULL grid_size = (ULL) ceil(it_todo * 1.f / (n_threads * CWR_LOOPS)); grid_size = min_macros(grid_size, device_prop.maxGridSize[0]); @@ -333,29 +375,35 @@ void jsf_uniform_orderstat_3d(asset_float *P_total_host, const float *log_du_hos grid_size = l_num_blocks; } - printf(">>> it_todo=%llu, grid_size=%llu, N_THREADS=%u\n\n", it_todo, grid_size, n_threads); + printf(">>> it_todo=%llu, grid_size=%llu, L_BLOCK=%llu, N_THREADS=%u\n\n", it_todo, grid_size, l_block, n_threads); - float *log_du_device; - cudaMalloc((void**)&log_du_device, sizeof(float) * L * (D + 1)); - cudaMemcpy(log_du_device, log_du_host, sizeof(float) * L * (D + 1), cudaMemcpyHostToDevice); + // Wait for asynchronous memory copies to finish. + gpuErrchk( cudaDeviceSynchronize() ); + + if (log_du_host != (float*) P_total_host) { + // the memory has been allocated + free(log_du_host); + } #if ASSET_DEBUG print_constants(); #endif - // Wait for asynchronous memory copies to finish. - // Don't know if this call is needed. - cudaDeviceSynchronize(); - - // Executing kernel - const unsigned long shared_mem_used = sizeof(asset_float) * l_block + sizeof(float) * l_block * (D + 1); + // Executing the kernel + const ULL shared_mem_used = sizeof(asset_float) * l_block + sizeof(float) * l_block * (D + 1); jsf_uniform_orderstat_3d_kernel<<>>(P_total_device, log_du_device); - // Transfer data back to host memory - cudaMemcpy(P_total_host, P_total_device, sizeof(asset_float) * L, cudaMemcpyDeviceToHost); + // Check for invalid launch argument. + gpuErrchk( cudaPeekAtLastError() ); + + // Transfer data back to host memory. + // If the exit code is non-zero, the kernel failed to complete the task. + cudaError_t cuda_completed_status = cudaMemcpy(P_total_host, P_total_device, sizeof(asset_float) * L, cudaMemcpyDeviceToHost); cudaFree(P_total_device); cudaFree(log_du_device); + + gpuErrchk( cuda_completed_status ); } @@ -363,42 +411,33 @@ int main(int argc, char* argv[]) { // compile command: nvcc -o asset.o asset.cu // (run after you fill the template keys L, N, D, etc.) if (argc != 3) { - fprintf(stderr, "Usage: ./asset.o /path/to/log_du.txt /path/to/P_total_output.txt\n"); + fprintf(stderr, "Usage: ./asset.o /path/to/log_du.dat /path/to/P_total_output.dat\n"); return 1; } char *log_du_path = argv[1]; char *P_total_path = argv[2]; - FILE *log_du_file = fopen(log_du_path, "r"); + FILE *log_du_file = fopen(log_du_path, "rb"); if (log_du_file == NULL) { fprintf(stderr, "File '%s' not found\n", log_du_path); return 1; } - float log_du_host[L * (D + 1)]; - uint32_t row, col, pos; - for (row = 0; row < L; row++) { - for (col = 0; col <= D; col++) { - pos = row * (D + 1) + col; - int read_floats = fscanf(log_du_file, "%f", log_du_host + pos); - assert(read_floats == 1); - } - } - fclose(log_du_file); + asset_float *P_total = (asset_float*) malloc(sizeof(asset_float) * L); - asset_float P_total[L]; - jsf_uniform_orderstat_3d(P_total, (const float*) log_du_host); + jsf_uniform_orderstat_3d(P_total, log_du_file); - FILE *P_total_file = fopen(P_total_path, "w"); + FILE *P_total_file = fopen(P_total_path, "wb"); if (P_total_file == NULL) { + free(P_total); fprintf(stderr, "Could not open '%s' for writing.\n", P_total_path); return 1; } - for (col = 0; col < L; col++) { - fprintf(P_total_file, "%f\n", P_total[col]); - } + fwrite(P_total, sizeof(asset_float), L, P_total_file); fclose(P_total_file); + free(P_total); + return 0; } diff --git a/elephant/asset/pmat_neighbors.cl b/elephant/asset/pmat_neighbors.cl new file mode 100644 index 000000000..fd240865e --- /dev/null +++ b/elephant/asset/pmat_neighbors.cl @@ -0,0 +1,46 @@ +#define FILT_SIZE {{FILT_SIZE}} +#define N_LARGEST {{N_LARGEST}} +#define PMAT_COLS {{PMAT_COLS}} +#define Y_OFFSET {{Y_OFFSET}} +#define NONZERO_SIZE {{NONZERO_SIZE}} +#define SYMMETRIC {{SYMMETRIC}} + +#define min_macros(a,b) ((a) < (b) ? (a) : (b)) + +__constant unsigned int filt_rows[] = {{filt_rows}}; +__constant unsigned int filt_cols[] = {{filt_cols}}; + + +__kernel void pmat_neighbors(__global float *lmat, __global const float *pmat) { + const unsigned long gid = get_global_id(0); + + const unsigned long y = gid / (PMAT_COLS - FILT_SIZE + 1); + const unsigned long x = gid - y * (PMAT_COLS - FILT_SIZE + 1); + + if (SYMMETRIC && (x > (y + Y_OFFSET))) { + return; + } + + float largest[N_LARGEST + 1]; + unsigned int i, j; + unsigned long pos; + float tmp; + for (i = 0; i < NONZERO_SIZE; i++) { + pos = PMAT_COLS * (y + filt_rows[i]) + x + filt_cols[i]; + largest[min_macros(i, N_LARGEST)] = pmat[pos]; + // insertion sort + for (j = min_macros(i, N_LARGEST); (j > 0) && (largest[j] > largest[j - 1]); j--) { + // swap + tmp = largest[j]; + largest[j] = largest[j - 1]; + largest[j - 1] = tmp; + } + } + + // lmat is already shifted by FILT_SIZE/2 in the first axis (Y) + pos = y * PMAT_COLS * N_LARGEST + (x + FILT_SIZE / 2) * N_LARGEST; + for (i = 0; i < N_LARGEST; i++) { + lmat[pos + i] = largest[N_LARGEST - 1 - i]; + } + +} diff --git a/elephant/asset/pmat_neighbors.cu b/elephant/asset/pmat_neighbors.cu new file mode 100644 index 000000000..f9e456f08 --- /dev/null +++ b/elephant/asset/pmat_neighbors.cu @@ -0,0 +1,52 @@ +#define FILT_SIZE {{FILT_SIZE}} +#define N_LARGEST {{N_LARGEST}} +#define PMAT_COLS {{PMAT_COLS}} +#define Y_OFFSET {{Y_OFFSET}} +#define NONZERO_SIZE {{NONZERO_SIZE}} +#define SYMMETRIC {{SYMMETRIC}} + +#define min_macros(a,b) ((a) < (b) ? (a) : (b)) + +#define IT_TODO {{IT_TODO}} + +__constant__ unsigned int filt_rows[NONZERO_SIZE]; +__constant__ unsigned int filt_cols[NONZERO_SIZE]; + + +__global__ void pmat_neighbors(float *lmat, const float *pmat) { + const unsigned long long gid = blockIdx.x * blockDim.x + threadIdx.x; + + if (gid > IT_TODO) { + return; + } + + const unsigned long long y = gid / (PMAT_COLS - FILT_SIZE + 1); + const unsigned long long x = gid - y * (PMAT_COLS - FILT_SIZE + 1); + + if (SYMMETRIC && (x > (y + Y_OFFSET))) { + return; + } + + float largest[N_LARGEST + 1]; + unsigned int i, j; + unsigned long long pos; + float tmp; + for (i = 0; i < NONZERO_SIZE; i++) { + pos = PMAT_COLS * (y + filt_rows[i]) + x + filt_cols[i]; + largest[min_macros(i, N_LARGEST)] = pmat[pos]; + // insertion sort + for (j = min_macros(i, N_LARGEST); (j > 0) && (largest[j] > largest[j - 1]); j--) { + // swap + tmp = largest[j]; + largest[j] = largest[j - 1]; + largest[j - 1] = tmp; + } + } + + // lmat is already shifted by FILT_SIZE/2 in the first axis (Y) + pos = y * PMAT_COLS * N_LARGEST + (x + FILT_SIZE / 2) * N_LARGEST; + for (i = 0; i < N_LARGEST; i++) { + lmat[pos + i] = largest[N_LARGEST - 1 - i]; + } + +} diff --git a/elephant/test/test_asset.py b/elephant/test/test_asset.py index 255f9c7e6..b8f47ff49 100644 --- a/elephant/test/test_asset.py +++ b/elephant/test/test_asset.py @@ -6,9 +6,11 @@ :license: Modified BSD, see LICENSE.txt for details. """ +import itertools +import os import random import unittest -import itertools +import warnings import neo import numpy as np @@ -29,10 +31,25 @@ HAVE_SKLEARN = True stretchedmetric2d = asset._stretched_metric_2d +try: + import pyopencl + HAVE_PYOPENCL = True +except ImportError: + HAVE_PYOPENCL = False + +try: + import pycuda + HAVE_CUDA = asset.get_cuda_capability_major() > 0 +except ImportError: + HAVE_CUDA = False + @unittest.skipUnless(HAVE_SKLEARN, 'requires sklearn') class AssetTestCase(unittest.TestCase): + def setUp(self): + os.environ['ELEPHANT_USE_OPENCL'] = '0' + def test_stretched_metric_2d_size(self): nr_points = 4 x = np.arange(nr_points) @@ -53,7 +70,7 @@ def test_stretched_metric_2d_symmetric(self): y = (1, 2, 0) stretch = 10 D = stretchedmetric2d(x, y, stretch=stretch, ref_angle=45) - assert_array_almost_equal(D, D.T, decimal=12) + assert_array_almost_equal(D, D.T, decimal=6) def test_stretched_metric_2d_equals_euclidean_if_stretch_1(self): x = np.arange(10) @@ -65,7 +82,7 @@ def test_stretched_metric_2d_equals_euclidean_if_stretch_1(self): points = np.vstack([x, y]).T E = scipy.spatial.distance_matrix(points, points) # assert D == E - assert_array_almost_equal(D, E, decimal=12) + assert_array_almost_equal(D, E, decimal=5) def test_sse_difference(self): a = {(1, 2): set([1, 2, 3]), (3, 4): set([5, 6]), (6, 7): set([0, 1])} @@ -189,6 +206,113 @@ def test_cluster_matrix_entries(self): correct = mat assert_array_equal(clustered, correct) + def test_cluster_matrix_entries_chunked(self): + np.random.seed(12) + mmat = np.random.randn(50, 50) > 0 + max_distance = 5 + min_neighbors = 4 + stretch = 2 + cmat_true = asset.ASSET.cluster_matrix_entries( + mmat, max_distance=max_distance, min_neighbors=min_neighbors, + stretch=stretch) + for working_memory in [1, 10, 100, 1000]: + cmat = asset.ASSET.cluster_matrix_entries( + mmat, max_distance=max_distance, min_neighbors=min_neighbors, + stretch=stretch, working_memory=working_memory) + assert_array_equal(cmat, cmat_true) + + def test_pmat_neighbors_gpu(self): + np.random.seed(12) + n_largest = 3 + pmat1 = np.random.random_sample((40, 40)).astype(np.float32) + np.fill_diagonal(pmat1, 0.5) + pmat2 = np.random.random_sample((70, 23)).astype(np.float32) + pmat3 = np.random.random_sample((27, 93)).astype(np.float32) + for pmat in (pmat1, pmat2, pmat3): + for filter_size in (4, 8, 11): + filter_shape = (filter_size, 3) + with warnings.catch_warnings(): + # ignore even filter sizes + warnings.simplefilter('ignore', UserWarning) + pmat_neigh = asset._PMatNeighbors( + filter_shape=filter_shape, n_largest=n_largest) + lmat_true = pmat_neigh.cpu(pmat) + if HAVE_PYOPENCL: + lmat_opencl = pmat_neigh.pyopencl(pmat) + assert_array_almost_equal(lmat_opencl, lmat_true) + if HAVE_CUDA: + lmat_cuda = pmat_neigh.pycuda(pmat) + assert_array_almost_equal(lmat_cuda, lmat_true) + + def test_pmat_neighbors_gpu_chunked(self): + np.random.seed(12) + filter_shape = (7, 3) + n_largest = 3 + pmat1 = np.random.random_sample((40, 40)).astype(np.float32) + np.fill_diagonal(pmat1, 0.5) + pmat2 = np.random.random_sample((70, 27)).astype(np.float32) + pmat3 = np.random.random_sample((41, 80)).astype(np.float32) + for pmat in (pmat1, pmat2, pmat3): + pmat_neigh = asset._PMatNeighbors(filter_shape=filter_shape, + n_largest=n_largest) + lmat_true = pmat_neigh.cpu(pmat) + for max_chunk_size in (17, 20, 29): + pmat_neigh.max_chunk_size = max_chunk_size + if HAVE_PYOPENCL: + lmat_opencl = pmat_neigh.pyopencl(pmat) + assert_array_almost_equal(lmat_opencl, lmat_true) + if HAVE_CUDA: + lmat_cuda = pmat_neigh.pycuda(pmat) + assert_array_almost_equal(lmat_cuda, lmat_true) + + def test_pmat_neighbors_gpu_overlapped_chunks(self): + # The pmat is chunked as follows: + # [(0, 11), (11, 22), (22, 33), (29, 40)] + # Two last chunks overlap. + np.random.seed(12) + pmat = np.random.random_sample((50, 50)).astype(np.float32) + pmat_neigh = asset._PMatNeighbors(filter_shape=(11, 5), n_largest=3, + max_chunk_size=12) + lmat_true = pmat_neigh.cpu(pmat) + if HAVE_PYOPENCL: + lmat_opencl = pmat_neigh.pyopencl(pmat) + assert_array_almost_equal(lmat_opencl, lmat_true) + if HAVE_CUDA: + lmat_cuda = pmat_neigh.pycuda(pmat) + assert_array_almost_equal(lmat_cuda, lmat_true) + + def test_pmat_neighbors_invalid_input(self): + np.random.seed(12) + pmat = np.random.random_sample((20, 20)) + np.fill_diagonal(pmat, 0.5) + + # Too large filter_shape + pmat_neigh = asset._PMatNeighbors(filter_shape=(11, 3), n_largest=3) + self.assertRaises(ValueError, pmat_neigh.compute, pmat) + pmat_neigh = asset._PMatNeighbors(filter_shape=(21, 3), n_largest=3) + np.fill_diagonal(pmat, 0.0) + self.assertRaises(ValueError, pmat_neigh.compute, pmat) + pmat_neigh = asset._PMatNeighbors(filter_shape=(11, 3), n_largest=3, + max_chunk_size=10) + if HAVE_PYOPENCL: + # max_chunk_size > filter_shape + self.assertRaises(ValueError, pmat_neigh.pyopencl, pmat) + if HAVE_CUDA: + # max_chunk_size > filter_shape + self.assertRaises(ValueError, pmat_neigh.pycuda, pmat) + + # Too small filter_shape + self.assertRaises(ValueError, asset._PMatNeighbors, + filter_shape=(11, 3), n_largest=100) + + # w >= l + self.assertRaises(ValueError, asset._PMatNeighbors, + filter_shape=(9, 9), n_largest=3) + + # not centered + self.assertWarns(UserWarning, asset._PMatNeighbors, + filter_shape=(10, 6), n_largest=3) + def test_intersection_matrix(self): st1 = neo.SpikeTrain([1, 2, 4] * pq.ms, t_stop=6 * pq.ms) st2 = neo.SpikeTrain([1, 3, 4] * pq.ms, t_stop=6 * pq.ms) @@ -302,12 +426,30 @@ def _wrong_order(a): len(matrix_entries_correct)) def test_next_sequence_sorted(self): + # This test shows the main idea of CUDA ASSET parallelization that + # allows reconstructing a 'sequence_sorted' from the iteration number + # and therefore getting rid of sequential nature of joint prob. + # matrix calculation. + def next_sequence_sorted(jsf, iteration): + # One-to-one correspondence with + # 'void next_sequence_sorted(int *sequence_sorted, ULL iteration)' + # function in asset.pycuda.py. + sequence_sorted = [] + element = jsf.n - 1 + for row in range(jsf.d - 1, -1, -1): + map_row = jsf.map_iterations[row] + while element > row and iteration < map_row[element]: + element -= 1 + iteration -= map_row[element] + sequence_sorted.append(element + 1) + return tuple(sequence_sorted) + for n in range(1, 15): for d in range(1, min(6, n + 1)): jsf = asset._JSFUniformOrderStat3D(n=n, d=d) for iter_id, seq_sorted_true in enumerate( jsf._combinations_with_replacement()): - seq_sorted = jsf._next_sequence_sorted(iteration=iter_id) + seq_sorted = next_sequence_sorted(jsf, iteration=iter_id) self.assertEqual(seq_sorted, seq_sorted_true) def test_invalid_values(self): @@ -327,7 +469,7 @@ def test_point_mass_output(self): u = np.arange(L * D, dtype=np.float32).reshape((-1, D)) u /= np.max(u) p_out = jsf.compute(u) - assert_array_almost_equal(p_out, [1., 0.]) + assert_array_almost_equal(p_out, [1., 0.], decimal=5) def test_precision(self): L = 2 @@ -346,6 +488,84 @@ def test_precision(self): assert_array_almost_equal(P_total_double, P_total_float, decimal=5) + def test_gpu(self): + np.random.seed(12) + for precision, L, n in itertools.product(['float', 'double'], + [1, 23, 100], [1, 3, 10]): + for d in range(1, min(4, n + 1)): + u = np.random.rand(L, d).cumsum(axis=1) + u /= np.max(u) + jsf = asset._JSFUniformOrderStat3D(n=n, d=d, + precision=precision) + du = np.diff(u, prepend=0, append=1, axis=1) + with warnings.catch_warnings(): + warnings.simplefilter('ignore', RuntimeWarning) + log_du = np.log(du, dtype=np.float32) + P_total_cpu = jsf.cpu(log_du) + for max_chunk_size in [None, 22]: + jsf.max_chunk_size = max_chunk_size + if HAVE_PYOPENCL: + P_total_opencl = jsf.pyopencl(log_du) + assert_array_almost_equal(P_total_opencl, P_total_cpu) + if HAVE_CUDA: + P_total_cuda = jsf.pycuda(log_du) + assert_array_almost_equal(P_total_cuda, P_total_cpu) + + def test_gpu_threads_and_cwr_loops(self): + # The num. of threads (work items) and CWR loops must not influence + # the result. + L, N, D = 100, 10, 3 + + u = np.arange(L * D, dtype=np.float32).reshape((-1, D)) + u /= np.max(u) + du = np.diff(u, prepend=0, append=1, axis=1) + with warnings.catch_warnings(): + warnings.simplefilter('ignore', RuntimeWarning) + log_du = np.log(du, dtype=np.float32) + + def run_test(jsf, jsf_backend): + P_expected = jsf_backend(log_du) + for threads in [1, 16, 32, 128, 1024]: + for cwr_loops in [1, 16, 128]: + jsf.cuda_threads = threads + jsf.cuda_cwr_loops = cwr_loops + P_total = jsf_backend(log_du) + assert_array_almost_equal(P_total, P_expected) + + if HAVE_PYOPENCL: + jsf = asset._JSFUniformOrderStat3D(n=N, d=D, precision='float') + run_test(jsf, jsf.pyopencl) + if HAVE_CUDA: + jsf = asset._JSFUniformOrderStat3D(n=N, d=D, precision='float') + run_test(jsf, jsf.pycuda) + + def test_gpu_chunked(self): + L, N, D = 100, 9, 3 + u = np.arange(L * D, dtype=np.float32).reshape((-1, D)) + u /= np.max(u) + du = np.diff(u, prepend=0, append=1, axis=1) + with warnings.catch_warnings(): + warnings.simplefilter('ignore', RuntimeWarning) + log_du = np.log(du, dtype=np.float32) + jsf = asset._JSFUniformOrderStat3D(n=N, d=D) + P_true = jsf.cpu(log_du) + for max_chunk_size in (13, 50): + jsf.max_chunk_size = max_chunk_size + if HAVE_PYOPENCL: + P_total = jsf.pyopencl(log_du) + assert_array_almost_equal(P_total, P_true) + if HAVE_CUDA: + P_total = jsf.pycuda(log_du) + assert_array_almost_equal(P_total, P_true) + + def test_watchdog(self): + L, N, D = 10, 7, 3 + u = np.arange(L * D, dtype=np.float32).reshape((-1, D)) + u /= np.max(u) - 1 + # 'u' is invalid input, which must lead to watchdog barking + jsf = asset._JSFUniformOrderStat3D(n=N, d=D) + self.assertWarns(UserWarning, jsf.compute, u) + @unittest.skipUnless(HAVE_SKLEARN, 'requires sklearn') class AssetTestIntegration(unittest.TestCase): diff --git a/elephant/utils.py b/elephant/utils.py index 0d7b34c46..aefb4d1d2 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -311,7 +311,7 @@ def get_cuda_capability_major(): int CUDA capability major version. """ - CUDA_SUCCESS = 0 + cuda_success = 0 for libname in ('libcuda.so', 'libcuda.dylib', 'cuda.dll'): try: cuda = ctypes.CDLL(libname) @@ -323,12 +323,12 @@ def get_cuda_capability_major(): # not found return 0 result = cuda.cuInit(0) - if result != CUDA_SUCCESS: + if result != cuda_success: return 0 device = ctypes.c_int() # parse the first GPU card only result = cuda.cuDeviceGet(ctypes.byref(device), 0) - if result != CUDA_SUCCESS: + if result != cuda_success: return 0 cc_major = ctypes.c_int() diff --git a/requirements/environment.yml b/requirements/environment.yml index 3149054b2..bed15319b 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -13,5 +13,6 @@ dependencies: - pandas - scikit-learn - statsmodels + - jinja2 - pip: - -r file:requirements.txt diff --git a/requirements/requirements-cuda.txt b/requirements/requirements-cuda.txt new file mode 100644 index 000000000..6b7685ff4 --- /dev/null +++ b/requirements/requirements-cuda.txt @@ -0,0 +1 @@ +pycuda>=2020.1 # used in ASSET diff --git a/requirements/requirements-opencl.txt b/requirements/requirements-opencl.txt new file mode 100644 index 000000000..4a9eabb2b --- /dev/null +++ b/requirements/requirements-opencl.txt @@ -0,0 +1,2 @@ +# conda install -c conda-forge pyopencl intel-compute-runtime +pyopencl>=2020.2.2 diff --git a/setup.py b/setup.py index e222b304c..22ad15b59 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ with open('requirements/requirements.txt') as fp: install_requires = fp.read().splitlines() extras_require = {} -for extra in ['extras', 'docs', 'tests', 'tutorials']: +for extra in ['extras', 'docs', 'tests', 'tutorials', 'cuda', 'opencl']: with open('requirements/requirements-{0}.txt'.format(extra)) as fp: extras_require[extra] = fp.read() From caf4a463c226e349ea49791c67faca9f7999d002 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Thu, 4 Mar 2021 18:05:13 +0100 Subject: [PATCH 17/63] Improved documentation: BibTex citations and structure by categories (#386) Co-authored-by: Michael Denker --- .gitignore | 2 +- doc/authors.rst | 5 - doc/bib/elephant.bib | 407 +++++++++++++++--- doc/citation.rst | 20 +- doc/conf.py | 2 +- doc/contribute.rst | 331 ++++++++++++++ doc/developers_guide.rst | 94 ---- doc/documentation_guide.rst | 43 -- doc/get_in_touch.rst | 31 -- doc/index.rst | 27 +- doc/install.rst | 25 +- doc/modules.rst | 133 ++++-- doc/reference/_spike_train_patterns.rst | 12 + doc/reference/_spike_train_processing.rst | 47 +- doc/reference/asset.rst | 2 +- doc/reference/causality.rst | 9 + doc/reference/cell_assembly_detection.rst | 16 +- doc/reference/change_point_detection.rst | 10 +- doc/reference/cubic.rst | 10 +- doc/reference/current_source_density.rst | 23 +- doc/reference/gpfa.rst | 9 + doc/reference/neo_tools.rst | 1 - doc/reference/pandas_bridge.rst | 1 - doc/reference/phase_analysis.rst | 1 - doc/reference/signal_processing.rst | 16 +- doc/reference/spade.rst | 9 + doc/reference/spectral.rst | 1 - doc/reference/spike_train_correlation.rst | 11 - doc/reference/spike_train_dissimilarity.rst | 6 - doc/reference/spike_train_generation.rst | 11 +- doc/reference/spike_train_surrogates.rst | 11 +- doc/reference/spike_train_synchrony.rst | 14 - doc/reference/sta.rst | 1 - doc/reference/unitary_event_analysis.rst | 6 +- doc/reference/waveform_features.rst | 10 +- doc/release_notes.rst | 36 +- doc/style_guide.rst | 2 +- doc/tutorials.rst | 13 + elephant/__init__.py | 2 +- elephant/asset/asset.py | 103 +++-- elephant/causality/granger.py | 34 +- elephant/cell_assembly_detection.py | 212 ++++----- elephant/change_point_detection.py | 199 +++++---- elephant/conversion.py | 102 +++-- elephant/cubic.py | 105 +++-- elephant/current_source_density.py | 36 +- elephant/current_source_density_src/README.md | 3 +- elephant/current_source_density_src/icsd.py | 92 ++-- elephant/gpfa/gpfa.py | 20 +- elephant/gpfa/gpfa_core.py | 5 +- elephant/gpfa/gpfa_util.py | 2 +- elephant/kernels.py | 98 +++-- elephant/neo_tools.py | 18 +- elephant/pandas_bridge.py | 13 +- elephant/parallel/__init__.py | 2 +- elephant/phase_analysis.py | 19 +- elephant/signal_processing.py | 170 +++++--- elephant/spade.py | 138 +++--- elephant/spectral.py | 94 +++- elephant/spike_train_correlation.py | 191 ++++---- elephant/spike_train_dissimilarity.py | 63 ++- elephant/spike_train_generation.py | 133 +++--- elephant/spike_train_surrogates.py | 160 +++---- elephant/spike_train_synchrony.py | 4 +- elephant/sta.py | 18 +- elephant/statistics.py | 321 ++++++++------ .../test/make_spike_extraction_test_data.py | 8 +- elephant/test/test_asset.py | 2 +- elephant/test/test_cell_assembly_detection.py | 34 +- elephant/test/test_change_point_detection.py | 22 +- elephant/test/test_conversion.py | 6 +- elephant/test/test_cubic.py | 16 +- elephant/test/test_gpfa.py | 2 +- elephant/test/test_icsd.py | 74 ++-- elephant/test/test_kernels.py | 2 +- elephant/test/test_neo_tools.py | 2 +- elephant/test/test_pandas_bridge.py | 2 +- elephant/test/test_phase_analysis.py | 2 +- elephant/test/test_signal_processing.py | 50 +-- elephant/test/test_spade.py | 2 +- elephant/test/test_spectral.py | 2 +- elephant/test/test_spike_train_correlation.py | 56 +-- .../test/test_spike_train_dissimilarity.py | 2 +- elephant/test/test_spike_train_generation.py | 26 +- elephant/test/test_spike_train_surrogates.py | 2 +- elephant/test/test_sta.py | 14 +- elephant/test/test_statistics.py | 8 +- elephant/test/test_unitary_event_analysis.py | 2 +- elephant/test/test_waveform_features.py | 2 +- elephant/unitary_event_analysis.py | 9 +- elephant/utils.py | 24 +- elephant/waveform_features.py | 36 +- readthedocs.yml | 5 +- 93 files changed, 2526 insertions(+), 1651 deletions(-) create mode 100644 doc/contribute.rst delete mode 100644 doc/developers_guide.rst delete mode 100644 doc/documentation_guide.rst delete mode 100644 doc/get_in_touch.rst create mode 100644 doc/reference/_spike_train_patterns.rst delete mode 100644 doc/reference/spike_train_correlation.rst delete mode 100644 doc/reference/spike_train_dissimilarity.rst delete mode 100644 doc/reference/spike_train_synchrony.rst diff --git a/.gitignore b/.gitignore index 5716c5191..acdf0fcb1 100644 --- a/.gitignore +++ b/.gitignore @@ -45,7 +45,7 @@ lib lib64 # sphinx build directory doc/_build -doc/reference/toctree/* +doc/reference/_toctree *.h5 # setup.py dist directory dist diff --git a/doc/authors.rst b/doc/authors.rst index 3172802fe..a811998ad 100644 --- a/doc/authors.rst +++ b/doc/authors.rst @@ -1,5 +1,3 @@ -.. _authors: - ************************ Authors and contributors ************************ @@ -8,9 +6,6 @@ The following people have contributed code and/or ideas to the current version of Elephant. The institutional affiliations are those at the time of the contribution, and may not be the current affiliation of a contributor. -Do you want to contribute to Elephant? Please refer to the -:ref:`developers_guide`. - * Alper Yegenoglu [1] * Andrew Davison [2] * Björn Müller [1] diff --git a/doc/bib/elephant.bib b/doc/bib/elephant.bib index 353d8ef8d..6a8930f11 100644 --- a/doc/bib/elephant.bib +++ b/doc/bib/elephant.bib @@ -18,90 +18,90 @@ @article{Granger69_424 } @article{Gruen02_43, - title = {Unitary events in multiple single-neuron spiking activity: I. Detection and significance}, - author = {Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, - year = {2002}, - journal = {Neural Comp.}, - volume = {14}, - number = {1}, - pages = {43--80}, - doi = {10.1162/089976602753284455} + title={Unitary events in multiple single-neuron spiking activity: I. Detection and significance}, + author={Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, + year={2002}, + journal={Neural Comp.}, + volume={14}, + number={1}, + pages={43--80}, + doi={10.1162/089976602753284455} } @article{Gruen02_81, - title = {Unitary events in multiple single-neuron spiking activity: II. Nonstationary data}, - author = {Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, - year = {2002}, - journal = {Neural Comp.}, - volume = {14}, - number = {1}, - pages = {81--119}, - doi = {10.1162/089976602753284464} + title={Unitary events in multiple single-neuron spiking activity: II. Nonstationary data}, + author={Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, + year={2002}, + journal={Neural Comp.}, + volume={14}, + number={1}, + pages={81--119}, + doi={10.1162/089976602753284464} } @article{Gruen03, - title = {Effects across trial non-stationarity on joint-spike events}, - author = {Gr\"{u}n, S. and Riehle, A. and Diesmann, M.}, - year = {2003}, - journal = {Biol. Cyb.}, - volume = {88}, - number = {5}, - pages = {335--51}, - doi = {10.1007/s00422-002-0386-2} + title={Effects across trial non-stationarity on joint-spike events}, + author={Gr\"{u}n, S. and Riehle, A. and Diesmann, M.}, + year={2003}, + journal={Biol. Cyb.}, + volume={88}, + number={5}, + pages={335--51}, + doi={10.1007/s00422-002-0386-2} } @article{Gruen09_1126, - title = {Data-driven significance estimation of precise spike correlation}, - author = {Gr\"{u}n, S.}, - year = {2009}, - journal = {J. Neurophysiol.}, - number = {101}, - pages = {1126--1140}, - doi = {10.1152/jn.00093.2008} + title={Data-driven significance estimation of precise spike correlation}, + author={Gr\"{u}n, S.}, + year={2009}, + journal={J. Neurophysiol.}, + number={101}, + pages={1126--1140}, + doi={10.1152/jn.00093.2008} } @article{Gruen99_67, - title = {Detecting unitary events without discretization of time}, - author = {Gr{\"u}n, S. and Diesmann, M. and Grammont, F. and Riehle, A. and Aertsen, A.}, - journal = {J. Neurosci. Meth.}, - year = {1999}, - volume = {94}, - number = {1}, - pages = {67--79}, - doi = {10.1016/s0165-0270(99)00126-0} + title={Detecting unitary events without discretization of time}, + author={Gr{\"u}n, S. and Diesmann, M. and Grammont, F. and Riehle, A. and Aertsen, A.}, + journal={J. Neurosci. Meth.}, + year={1999}, + volume={94}, + number={1}, + pages={67--79}, + doi={10.1016/s0165-0270(99)00126-0} } @article{Riehle97_1950, - title = {Spike synchronization and rate modulation differentially involved in motor cortical function}, - author = {Riehle, A. and Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, - year = {1997}, - journal = {Science}, - volume = {278}, - number = {5345}, - pages = {1950--1953}, - doi = {10.1126/science.278.5345.1950} + title={Spike synchronization and rate modulation differentially involved in motor cortical function}, + author={Riehle, A. and Gr{\"u}n, S. and Diesmann, M. and Aertsen, A.}, + year={1997}, + journal={Science}, + volume={278}, + number={5345}, + pages={1950--1953}, + doi={10.1126/science.278.5345.1950} } @article{Seth07_1667, - author = {Seth, A. }, - title = {Granger causality}, - year = {2007}, - journal = {Scholarpedia}, - volume = {2}, - number = {7}, - pages = {1667}, - doi = {10.4249/scholarpedia.1667}, - note = {revision \#127333} + author={Seth, A. }, + title={Granger causality}, + year={2007}, + journal={Scholarpedia}, + volume={2}, + number={7}, + pages={1667}, + doi={10.4249/scholarpedia.1667}, + note={revision \#127333} } @article{Stella19_104022, - title = {3d-{SPADE}: {S}ignificance evaluation of spatio-temporal patterns of various temporal extents}, - author = {Stella, A. and Quaglio, P. and Torre, E. and Gr{\"u}n, S.}, - year = {2019}, - journal = {Biosystems}, - volume = {185}, - pages = {104022}, - doi = {10.1016/j.biosystems.2019.104022} + title={3d-{SPADE}: {S}ignificance evaluation of spatio-temporal patterns of various temporal extents}, + author={Stella, A. and Quaglio, P. and Torre, E. and Gr{\"u}n, S.}, + year={2019}, + journal={Biosystems}, + volume={185}, + pages={104022}, + doi={10.1016/j.biosystems.2019.104022} } @article{Torre16_e1004939, @@ -126,12 +126,277 @@ @article{Ciba18_136 } @article{Rostami17_3, - title = {[{Re}] {S}pike synchronization and rate modulation differentially involved in motor cortical function}, - author = {Rostami, V. and Ito, J. and Denker, M. and Gr{\"u}n, S.}, - year = {2017}, - journal = {ReScience}, - volume = {3}, - number = {1}, - pages = {3}, - doi = {10.5281/zenodo.583814} + title={[{Re}] {S}pike synchronization and rate modulation differentially involved in motor cortical function}, + author={Rostami, V. and Ito, J. and Denker, M. and Gr{\"u}n, S.}, + year={2017}, + journal={ReScience}, + volume={3}, + number={1}, + pages={3}, + doi={10.5281/zenodo.583814} +} + +@article{Gerstein2004_203, + title={Searching for significance in spatio-temporal firing patterns}, + author={Gerstein, George L}, + journal={Acta Neurobiologiae Experimentalis}, + volume={64}, + number={2}, + pages={203--208}, + year={2004}, + publisher={Warsaw; Nencki Institute of Experimental Biology; 1999} +} + +@article{Louis2010_127, + title={Surrogate spike train generation through dithering in operational time}, + author={Louis, Sebastien GR and Diesmann, Markus and others}, + journal={Frontiers in computational neuroscience}, + volume={4}, + pages={127}, + year={2010}, + publisher={Frontiers} +} + +@incollection{Louis2010_359, + title={Generation and selection of surrogate methods for correlation analysis}, + author={Louis, Sebastien and Borgelt, Christian and Gr{\"u}n, Sonja}, + booktitle={Analysis of Parallel Spike Trains}, + volume={7}, + pages={359--382}, + year={2010}, + publisher={Springer}, + doi={10.1007/978-1-4419-5675-0_17} +} + +@incollection{Eggermont2010_77, + title={Pair-correlation in the time and frequency domain}, + author={Eggermont, Jos J}, + booktitle={Analysis of parallel spike trains}, + volume={7}, + pages={77--102}, + year={2010}, + publisher={Springer}, + doi={10.1007/978-1-4419-5675-0_5} +} + +@article{Hatsopoulos2007_5105, + title={Encoding of movement fragments in the motor cortex}, + author={Hatsopoulos, Nicholas G and Xu, Qingqing and Amit, Yali}, + journal={Journal of Neuroscience}, + volume={27}, + number={19}, + pages={5105--5114}, + year={2007}, + publisher={Soc Neuroscience} +} + +@article{Rossum2001_751, + title={A novel spike distance}, + author={Rossum, MCW van}, + journal={Neural computation}, + volume={13}, + number={4}, + pages={751--763}, + year={2001}, + publisher={MIT Press} +} + +@article{Wieland2015_040901, + title={Slow fluctuations in recurrent networks of spiking neurons}, + author={Wieland, Stefan and Bernardi, Davide and Schwalger, Tilo and Lindner, Benjamin}, + journal={Physical Review E}, + volume={92}, + number={4}, + pages={040901}, + year={2015}, + publisher={APS} +} + +@article{Cutts2014_14288, + title={Detecting pairwise correlations in spike trains: an objective comparison of methods and application to the study of retinal waves}, + author={Cutts, Catherine S and Eglen, Stephen J}, + journal={Journal of Neuroscience}, + volume={34}, + number={43}, + pages={14288--14303}, + year={2014}, + publisher={Soc Neuroscience} +} + +@article{Holt1996_1806, + title={Comparison of discharge variability in vitro and in vivo in cat visual cortex neurons}, + author={Holt, Gary R and Softky, William R and Koch, Christof and Douglas, Rodney J}, + journal={Journal of neurophysiology}, + volume={75}, + number={5}, + pages={1806--1814}, + year={1996}, + publisher={American Physiological Society Bethesda, MD} +} + +@article{Shinomoto2003_2823, + title={Differences in spiking patterns among cortical neurons}, + author={Shinomoto, Shigeru and Shima, Keisetsu and Tanji, Jun}, + journal={Neural computation}, + volume={15}, + number={12}, + pages={2823--2842}, + year={2003}, + publisher={MIT Press} +} + +@article{Shinomoto2009_e1000433, + title={Relating neuronal firing patterns to functional differentiation of cerebral cortex}, + author={Shinomoto, Shigeru and Kim, Hideaki and Shimokawa, Takeaki and Matsuno, Nanae and Funahashi, Shintaro and Shima, Keisetsu and Fujita, Ichiro and Tamura, Hiroshi and Doi, Taijiro and Kawano, Kenji and others}, + journal={PLoS Comput Biol}, + volume={5}, + number={7}, + pages={e1000433}, + year={2009}, + publisher={Public Library of Science} +} + +@article{Shimazaki2010_171, + title={Kernel bandwidth optimization in spike rate estimation}, + author={Shimazaki, Hideaki and Shinomoto, Shigeru}, + journal={Journal of computational neuroscience}, + volume={29}, + number={1-2}, + pages={171--182}, + year={2010}, + publisher={Springer} +} + +@inproceedings{Gruen2007_96, + title={Impact of higher-order correlations on coincidence distributions of massively parallel data}, + author={Gr{\"u}n, Sonja and Abeles, Moshe and Diesmann, Markus}, + booktitle={International School on Neural Networks, Initiated by IIASS and EMFCSC}, + volume={5286}, + pages={96--114}, + year={2007}, + organization={Springer} +} + +@article{Torre2013_132, + title={Statistical evaluation of synchronous spike patterns extracted by frequent item set mining}, + author={Torre, Emiliano and Picado-Mui{\~n}o, David and Denker, Michael and Borgelt, Christian and Gr{\"u}n, Sonja}, + journal={Frontiers in computational neuroscience}, + volume={7}, + pages={132}, + year={2013}, + publisher={Frontiers} +} + +@article{Quaglio2017_41, + title={Detection and evaluation of spatio-temporal spike patterns in massively parallel spike train data with spade}, + author={Quaglio, Pietro and Yegenoglu, Alper and Torre, Emiliano and Endres, Dominik M and Gr{\"u}n, Sonja}, + journal={Frontiers in computational neuroscience}, + volume={11}, + pages={41}, + year={2017}, + publisher={Frontiers} +} + +@article{Stella2019_104022, + title={3d-SPADE: Significance evaluation of spatio-temporal patterns of various temporal extents}, + author={Stella, Alessandra and Quaglio, Pietro and Torre, Emiliano and Gr{\"u}n, Sonja}, + journal={Biosystems}, + volume={185}, + pages={104022}, + year={2019}, + publisher={Elsevier} +} + +@article{Nawrot2008_374, + title={Measurement of variability dynamics in cortical spike trains}, + author={Nawrot, Martin P and Boucsein, Clemens and Molina, Victor Rodriguez and Riehle, Alexa and Aertsen, Ad and Rotter, Stefan}, + journal={Journal of neuroscience methods}, + volume={169}, + number={2}, + pages={374--390}, + year={2008}, + publisher={Elsevier} +} + +@article{Kuhn2003_67, + title={Higher-order statistics of input ensembles and the response of simple model neurons}, + author={Kuhn, Alexandre and Aertsen, Ad and Rotter, Stefan}, + journal={Neural computation}, + volume={15}, + number={1}, + pages={67--101}, + year={2003}, + publisher={MIT Press} +} + +@article{Staude2010_327, + title={CuBIC: cumulant based inference of higher-order correlations in massively parallel spike trains}, + author={Staude, Benjamin and Rotter, Stefan and Gr{\"u}n, Sonja}, + journal={Journal of computational neuroscience}, + volume={29}, + number={1-2}, + pages={327--350}, + year={2010}, + publisher={Springer} +} + +@article{Le2001_83, + title={Comparison of Hilbert transform and wavelet methods for the analysis of neuronal synchrony}, + author={Le Van Quyen, Michel and Foucher, Jack and Lachaux, Jean-Philippe and Rodriguez, Eugenio and Lutz, Antoine and Martinerie, Jacques and Varela, Francisco J}, + journal={Journal of neuroscience methods}, + volume={111}, + number={2}, + pages={83--98}, + year={2001}, + publisher={Elsevier} +} + +@article{Farge1992_395, + title={Wavelet transforms and their applications to turbulence}, + author={Farge, Marie}, + journal={Annual review of fluid mechanics}, + volume={24}, + number={1}, + pages={395--458}, + year={1992}, + publisher={Annual reviews 4139 El Camino Way, PO Box 10139, Palo Alto, CA 94303-0139, USA} +} + +@article{Stoica2005, + title={Spectral analysis of signals}, + author={Stoica, Petre and Moses, Randolph L and others}, + journal={Prentice Hall}, + pages={}, + year={2005}, + publisher={Pearson Prentice Hall Upper Saddle River, NJ} +} + +@article{Messer2014_2027, + title={A multiple filter test for the detection of rate changes in renewal processes with varying variance}, + author={Messer, Michael and Kirchner, Marietta and Schiemann, Julia and Roeper, Jochen and Neininger, Ralph and Schneider, Gaby and others}, + journal={The Annals of Applied Statistics}, + volume={8}, + number={4}, + pages={2027--2067}, + year={2014}, + publisher={Institute of Mathematical Statistics} +} + +@article{Russo2017_e19428, + title={Cell assemblies at multiple time scales with arbitrary lag constellations}, + author={Russo, Eleonora and Durstewitz, Daniel}, + journal={Elife}, + volume={6}, + pages={e19428}, + year={2017}, + publisher={eLife Sciences Publications Limited} +} + +@article{Yu2008_1881, + title={Gaussian-process factor analysis for low-dimensional single-trial analysis of neural population activity}, + author={Yu, Byron M and Cunningham, John P and Santhanam, Gopal and Ryu, Stephen and Shenoy, Krishna V and Sahani, Maneesh}, + journal={Advances in neural information processing systems}, + volume={21}, + pages={1881--1888}, + year={2008} } diff --git a/doc/citation.rst b/doc/citation.rst index 4e4fb242b..503eaba66 100644 --- a/doc/citation.rst +++ b/doc/citation.rst @@ -2,16 +2,19 @@ Citing Elephant *************** -To refer to the Elephant software package in publications, please use: **Elephant (RRID:SCR_003833)**. +To refer to the Elephant software package in publications, please use: +**Elephant (RRID:SCR_003833)**. To cite Elephant, please use: -**Denker M, Yegenoglu A, Grün S (2018) Collaborative HPC-enabled workflows on the HBP Collaboratory using the Elephant framework. Neuroinformatics 2018, P19. doi: 10.12751/incf.ni2018.0019** +**Denker M, Yegenoglu A, Grün S (2018) Collaborative HPC-enabled workflows on +the HBP Collaboratory using the Elephant framework. Neuroinformatics 2018, P19. +doi: 10.12751/incf.ni2018.0019** A BibTeX entry for LaTeX users is: -.. code-block:: bibtex +.. code-block:: none @conference{elephant18, author = {Denker, M. and Yegenoglu, A. and Grün, S.}, @@ -22,13 +25,14 @@ A BibTeX entry for LaTeX users is: doi = {10.12751/incf.ni2018.0019}, url = {https://abstracts.g-node.org/conference/NI2018/abstracts#/uuid/023bec4e-0c35-4563-81ce-2c6fac282abd}, } - + Further publications directly related to Elephant development -:cite:`citations-Rostami17_3,citations-Stella19_104022` (see -`doc/bib/elephant.bib` for full BibTeX entries). +:cite:`citations-Rostami17_3,citations-Stella19_104022` (see a list of full +`BibTex references `_ +used in Elephant documentation). .. bibliography:: bib/elephant.bib - :labelprefix: citations- + :labelprefix: ref :keyprefix: citations- - :style: unsrt + :style: unsrt diff --git a/doc/conf.py b/doc/conf.py index a580dd7d1..bb7b338ec 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -123,7 +123,7 @@ # the autosummary fields of each module. autosummary_generate = True -# Set to False to not overwrite our custom toctree/*.rst +# Set to False to not overwrite the custom _toctree/*.rst autosummary_generate_overwrite = True # -- Options for HTML output --------------------------------------------- diff --git a/doc/contribute.rst b/doc/contribute.rst new file mode 100644 index 000000000..3a4629bc1 --- /dev/null +++ b/doc/contribute.rst @@ -0,0 +1,331 @@ +.. _contribute: + +======================== +Contributing to Elephant +======================== + +You are here to help with Elephant? Awesome, feel welcome to get in touch with +us by asking questions, proposing features and improvements to Elephant. + +For guidelines on code documentation, please see the :ref:`documentation_guide` +below. + + +.. note:: + + We highly recommend to get in touch with us *before* starting to implement a + new feature in Elephant. This way, we can point out synergies with complementary + efforts and help in designing your implementation such that its integration + into Elephant will be an easy process. + + +.. _get_in_touch: + +************ +Get in touch +************ + +Using the mailing list +---------------------- + +General discussion of Elephant development takes place in the +`NeuralEnsemble Google group `_. + +Please raise concrete issues, bugs, and feature requests on the `issue tracker`_. + + +Using the issue tracker +----------------------- + +If you find a bug in Elephant, please create a new ticket on the +`issue tracker`_. Choose one of the available templates - "Bug report", +"Feature request", or "Questions". +Choose an issue title that is as specific as possible to the problem you've found, and +in the description give as much information as you think is necessary to +recreate the problem. The best way to do this is to create the shortest possible +Python script that demonstrates the problem, and attach the file to the ticket. + +If you have an idea for an improvement to Elephant, create a ticket with type +"enhancement". If you already have an implementation of the idea, open a +`pull request `_. + +.. _set_up_an_environment: + +************************************ +Setting up a development environment +************************************ + +In order to contribute to the Elephant code, you must set up a Python environment on +your local machine. + +1. Fork `Elephant `_ as described + in `Fork a repo `_. + Download Elephant source code from your forked repo:: + + $ git clone git://github.com//elephant.git + $ cd elephant + +2. Set up the virtual environment (either via pip or conda): + +.. tabs:: + + .. tab:: conda (recommended) + + .. code-block:: sh + + conda env create -f requirements/environment.yml + conda activate elephant + pip install -r requirements/requirements-tests.txt + + .. tab:: pip + + .. code-block:: sh + + python -m venv elephant-env + source elephant-env/bin/activate + + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt # optional + pip install -r requirements/requirements-tests.txt + + +3. Before you make any changes, run the test suite to make sure all the tests + pass on your system:: + + $ nosetests . + + You can specify a particular module to test, for example + ``test_statistics.py``:: + + $ nosetests elephant/test/test_statistics.py + + At the end, if you see "OK", then all the tests passed (or were skipped + because certain dependencies are not installed), otherwise it will report + on tests that failed or produced errors. + + +************************ +Adding new functionality +************************ + +After you've set up a development environment, implement a functionality you +want to add in Elephant. This includes, in particular: + + * fixing a bug; + * improving the documentation; + * adding a new functionality. + +Writing code +------------ + +Imagine that you want to add a novel +statistical measure of a list of spike trains that returns an analog signal in the existing module ``elephant/statistics.py``. +Let's call it ``statistics_x``. + +Elephant relies on Neo structures that use Quantities extensively, allowing +the users to conveniently specify physical units (e.g., seconds and milliseconds) +of input objects. Typically, to avoid computationally expensive quantities +rescaling operation on large input arrays, we check that the main data objects +- spike trains or analog signals - share the same units and rescale additional +parameters (t_start, t_stop, bin_size, etc.) to the units of input objects. + +.. code-block:: python + + import neo + import quantities as pq + + from elephant.utils import check_same_units + + + def statistics_x(spiketrains, t_start=None, t_stop=None): + """ + Compute the X statistics of spike trains. + + Parameters + ---------- + spiketrains : list of neo.SpikeTrain + Input spike trains. + t_start, t_stop : pq.Quantity or None + Start and stop times to compute the statistics over the specified + interval. If None, extracted from the input spike trains. + + Returns + ------- + signal : neo.AnalogSignal + The X statistics of input spike trains. + (More description follows.) + + """ + check_same_units(spiketrains, object_type=neo.SpikeTrain) + + # alternatively, if spiketrains are required to be aligned in time, + # when t_start and t_stop are not specified, use 'check_neo_consistency' + # check_neo_consistency(spiketrains, object_type=neo.SpikeTrain, t_start=t_start, t_stop=t_stop) + + # convert everything to spiketrain units and strip off the units + if t_start is None: + t_start = spiketrains[0].t_start + if t_stop is None: + t_stop = spiketrains[0].t_stop + units = spiketrains[0].units + t_start = t_start.rescale(units).item() + t_stop = t_stop.rescale(units).item() + spiketrains = [spiketrain.magnitude for spiketrain in spiketrains] + + # do the analysis here on unit-less spike train arrays + x = ... + + signal = neo.AnalogSignal(x, + units=..., + t_start=t_start, + sampling_rate=..., + name="X statistics of spiketrains", + ...) + return signal + + +Testing code +------------ + +Write at least one test in ``elephant/test/test_module_name.py`` file that +covers the functionality. + +For example, to check the correctness of the implemented ``statistics_x`` +function, we add unittest code in ``elephant/test/test_statistics.py``, +something like + +.. code-block:: python + + import unittest + + import neo + import quantities as pq + from numpy.testing import assert_array_almost_equal + + from elephant.statistics import statistics_x + + + class StatisticsXTestCase(unittest.TestCase): + def test_statistics_x_correctness(self): + spiketrain1 = neo.SpikeTrain([0.3, 4.5, 7.8], t_stop=10, units='s') + spiketrain2 = neo.SpikeTrain([2.4, 5.6], t_stop=10, units='s') + result = statistics_x([spiketrain1, spiketrain2]) + self.assertIsInstance(result, neo.AnalogSignal) + self.assertEqual(result.t_start, 0 * pq.s) + expected_magnitude = [0, 1, 2] + assert_array_almost_equal(result.magnitude, expected_magnitude) + ... # more checking + + +Pushing the changes and creating a pull request +----------------------------------------------- + +Now you're ready to share the code publicly. + +1. Commit your changes: + + .. code-block:: sh + + git add . + git commit -m "informative commit message" + git push + + If this is your first commitment to Elephant, please add your name and + affiliation/employer in :file:`doc/authors.rst` + +2. Open a `pull request `_. + Then we will guide you through the process of merging your code into Elephant. + +That's all! We're happy to assist you throughout the process of contributing. + +If you experience any problems during one of the steps below, please contact us +and we'll help you. + + +.. _documentation_guide: + +******************* +Documentation Guide +******************* + + +Writing documentation +--------------------- + +Each module (python source file) should start with a short description of the +listed functionality. Class and function docstrings should conform to the +`NumPy docstring standard `_. + +.. note:: Please refer to our :doc:`style_guide`. + + +Building documentation +---------------------- + +The documentation in :file:`doc/` folder is written in `reStructuredText +`_, using the +`Sphinx `_ documentation system. To build the +documentation locally on a Linux system, follow these steps: + +1. Install requirements-docs.txt and requirements-tutorials.txt the same way + it's explained in :ref:`set_up_an_environment` step 3: + + .. code-block:: sh + + pip install -r requirements/requirements-docs.txt + pip install -r requirements/requirements-tutorials.txt + +2. Build the documentation: + + + .. code-block:: sh + + cd doc + export PYTHONPATH=${PYTHONPATH}.:../.. + make html + + ``PYTHONPATH`` environmental variable is set in order to find Elephant + package while executing jupyter notebooks that are part of the documentation. + You may also need to install LaTeX support: + + .. code-block:: sh + + sudo apt-get install texlive-full + +3. Open :file:`_build/html/index.html` in your browser. + +4. (Optional) To check that all URLs in the documentation are correct, run: + + .. code-block:: sh + + make linkcheck + + +Citations +--------- + +The citations are in BibTeX format, stored in `doc/bib/elephant.bib +`_. + +To cite Elephant, refer to :doc:`citation`. + +Each module in ``doc/reference`` folder ends with the reference section: + +.. code-block:: rst + + References + ---------- + + .. bibliography:: ../bib/elephant.bib + :labelprefix: + :keyprefix: - + :style: unsrt + +where ```` is (by convention) the Python source file name, and +```` is what will be displayed to the users. + +For example, ``:cite:'spade-Torre2013_132'`` will be rendered as ``sp1`` in +the built HTML documentation, if ```` is set to ``sp`` +and ```` - to ``spade``. + +.. _Issue tracker: https://github.com/NeuralEnsemble/elephant/issues diff --git a/doc/developers_guide.rst b/doc/developers_guide.rst deleted file mode 100644 index adf9a9f31..000000000 --- a/doc/developers_guide.rst +++ /dev/null @@ -1,94 +0,0 @@ -.. _developers_guide: - -================= -Developers' Guide -================= - -.. note:: - 1. The documentation guide (how to write a good documentation, naming - conventions, docstring examples) is in the :ref:`documentation_guide`. - - 2. We highly recommend to get in touch with us (see :ref:`get_in_touch`) *before* starting - to implement a new feature in Elephant. This way, we can point out synergies with - complementary efforts and help in designing your implementation such that its integration - into Elephant will be an easy process. - - 3. If you experience any problems during one of the steps below, please - contact us and we'll help you. - - -1. Follow the instructions in :ref:`prerequisites` to setup a clean conda - environment. To be safe, run:: - - $ pip uninstall elephant - - to uninstall ``elephant`` in case you've installed it previously as a pip - package. - -2. Fork `Elephant `_ as described - in `Fork a repo `_. - Download Elephant source code from your forked repo:: - - $ git clone git://github.com//elephant.git - $ cd elephant - -3. Install the requirements (either via pip or conda): - -.. tabs:: - - .. tab:: pip - - .. code-block:: sh - - pip install -r requirements/requirements.txt - pip install -r requirements/requirements-extras.txt # optional - pip install -r requirements/requirements-tests.txt - - .. tab:: conda - - .. code-block:: sh - - conda env create -f requirements/environment.yml - conda activate elephant - pip install -r requirements/requirements-tests.txt - - -4. Before you make any changes, run the test suite to make sure all the tests - pass on your system:: - - $ nosetests . - - You can specify a particular module to test, for example - ``test_statistics.py``:: - - $ nosetests elephant/test/test_statistics.py - - At the end, if you see "OK", then all the tests passed (or were skipped - because certain dependencies are not installed), otherwise it will report - on tests that failed or produced errors. - -5. **Implement the functional you want to add in Elephant**. This includes - (either of them): - - * fixing a bug; - * improving the documentation; - * adding a new functionality. - -6. If it is a new functionality, please write: - - - documentation (refer to :ref:`documentation_guide`); - - tests to cover your new functions as much as possible. - -7. Run the tests again as described in step 4. - -8. Commit your changes:: - - $ git add . - $ git commit -m "informative commit message" - $ git push - - If this is your first commit to the project, please add your name and - affiliation/employer to :file:`doc/authors.rst` - -9. Open a `pull request `_. - Then we'll merge your code in Elephant. diff --git a/doc/documentation_guide.rst b/doc/documentation_guide.rst deleted file mode 100644 index f41d53abe..000000000 --- a/doc/documentation_guide.rst +++ /dev/null @@ -1,43 +0,0 @@ -.. _documentation_guide: - -=================== -Documentation Guide -=================== - - -Writing the documentation -------------------------- - -Each module (python source file) should start with a short description of the -listed functionality. Class and function docstrings should conform to the -`NumPy docstring standard `_. - -.. note:: We highly recommend exploring our :ref:`style_guide`. - - -Building the documentation --------------------------- - -The documentation in :file:`doc/` folder is written in `reStructuredText -`_, using the -`Sphinx `_ documentation system. To build the -documentation: - -1. Install requirements-docs.txt and requirements-tutorials.txt in the same way - as it's explained in :ref:`developers_guide` step 3:: - - $ pip install -r requirements/requirements-docs.txt - $ pip install -r requirements/requirements-tutorials.txt - -2. Build the documentation:: - - $ cd doc - $ export PYTHONPATH=.:../.. # to find elephant package - $ make html - -3. Open :file:`_build/html/index.html` in your browser. - -4. (Optional) To check that all URLs in the documentation are correct, run:: - - $ make linkcheck - diff --git a/doc/get_in_touch.rst b/doc/get_in_touch.rst deleted file mode 100644 index 468ce6daf..000000000 --- a/doc/get_in_touch.rst +++ /dev/null @@ -1,31 +0,0 @@ -.. _get_in_touch: - -==================== -Get in touch with us -==================== - -Using the mailing list -********************** - -General discussion of Elephant development takes place in the -`NeuralEnsemble Google group `_. - -Discussion of issues should take place on the `Issue tracker`_. - - -Using the issue tracker -*********************** - -If you find a bug in Elephant, please create a new ticket on the -`Issue tracker`_. -Choose a name that is as specific as possible to the problem you've found, and -in the description give as much information as you think is necessary to -recreate the problem. The best way to do this is to create the shortest possible -Python script that demonstrates the problem, and attach the file to the ticket. - -If you have an idea for an improvement to Elephant, create a ticket with type -"enhancement". If you already have an implementation of the idea, open a -`pull request `_. - - -.. _Issue tracker: https://github.com/NeuralEnsemble/elephant/issues diff --git a/doc/index.rst b/doc/index.rst index 504b15f6a..f8432bf22 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -1,6 +1,6 @@ -********************************************* +============================================= Elephant - Electrophysiology Analysis Toolkit -********************************************* +============================================= *Elephant* (Electrophysiology Analysis Toolkit) is an emerging open-source, community centered library for the analysis of electrophysiological data in @@ -30,25 +30,34 @@ The API uses and extends the same structure as in Elephant to ensure intuitive usage for scientists that are used to Elephant. - +***************** Table of Contents ------------------ +***************** + +* :doc:`install` +* :doc:`tutorials` +* :doc:`modules` +* :doc:`contribute` +* :doc:`release_notes` +* :doc:`acknowledgments` +* :doc:`authors` +* :doc:`citation` + .. toctree:: - :maxdepth: 1 + :maxdepth: 2 + :hidden: install tutorials modules - developers_guide - authors + contribute release_notes - get_in_touch acknowledgments + authors citation - .. Indices and tables .. ================== diff --git a/doc/install.rst b/doc/install.rst index a86458b69..541e44565 100644 --- a/doc/install.rst +++ b/doc/install.rst @@ -1,8 +1,8 @@ .. _install: -************ +============ Installation -************ +============ The easiest way to install Elephant is by creating a conda environment, followed by ``pip install elephant``. Below is the explanation of how to proceed with these two steps. @@ -10,8 +10,9 @@ Below is the explanation of how to proceed with these two steps. .. _prerequisites: +************* Prerequisites -============= +************* Elephant requires `Python `_ 3.6, 3.7, 3.8, or 3.9. @@ -42,9 +43,9 @@ Elephant requires `Python `_ 3.6, 3.7, 3.8, or 3.9. sudo apt-get install python-pip python-numpy python-scipy python-pip python-six python-tqdm - +************ Installation -============ +************ .. tabs:: @@ -116,8 +117,9 @@ Installation conda activate elephant pip install -e . +*********** MPI support ------------ +*********** Some Elephant modules (ASSET, SPADE, etc.) are parallelized to run with MPI. In order to make use of MPI parallelization, you need to install ``mpi4py`` @@ -131,7 +133,7 @@ package: conda install -c conda-forge mpi4py - .. tab:: pip (Debian/Ubuntu) + .. tab:: pip (Linux) .. code-block:: sh @@ -148,8 +150,9 @@ For more information, refer to `mpi4py `_ documentation. +*********************** CUDA and OpenCL support ------------------------ +*********************** :ref:`asset` module supports CUDA and OpenCL. These are experimental features. You can have one, both, or none installed in your system. @@ -208,11 +211,11 @@ You can have one, both, or none installed in your system. unresponsive until the compute program terminates. +************ Dependencies ------------- +************ -Elephant relies on the following packages (automatically installed when you -run ``pip install elephant``): +Elephant relies on two special packages, installed by default: * `quantities `_ - support for physical quantities with units (mV, ms, etc.) * `neo `_ - electrophysiology data manipulations diff --git a/doc/modules.rst b/doc/modules.rst index c99f87d66..0c07f6bbf 100644 --- a/doc/modules.rst +++ b/doc/modules.rst @@ -1,36 +1,99 @@ -**************************** +============================ Function Reference by Module -**************************** - -.. toctree:: - :maxdepth: 1 - - reference/asset - reference/causality - reference/cell_assembly_detection - reference/change_point_detection - reference/conversion - reference/cubic - reference/current_source_density - reference/gpfa - reference/kernels - reference/neo_tools - reference/pandas_bridge - reference/parallel - reference/phase_analysis - reference/signal_processing - reference/spade - reference/spectral - reference/spike_train_generation - reference/spike_train_surrogates - reference/sta - reference/statistics - reference/unitary_event_analysis - reference/utils - reference/waveform_features - - -.. toctree:: - :maxdepth: 2 - - reference/_spike_train_processing +============================ + + +**************************************************** +Local field potentials (LFPs) and population signals +**************************************************** + + +.. toctree:: + :maxdepth: 1 + + reference/signal_processing + reference/spectral + reference/causality + reference/current_source_density + + +************ +Spike trains +************ + +.. toctree:: + :maxdepth: 2 + + reference/statistics + +.. toctree:: + :maxdepth: 2 + + reference/_spike_train_processing + reference/_spike_train_patterns + +.. toctree:: + :maxdepth: 1 + + reference/change_point_detection + reference/gpfa +.. toctree:: + :maxdepth: 1 + + reference/spike_train_surrogates + +.. toctree:: + :maxdepth: 2 + + reference/spike_train_generation + + +******************************** +LFPs and spike trains (combined) +******************************** + +.. toctree:: + :maxdepth: 1 + + reference/sta + reference/phase_analysis + +******* +Kernels +******* + +.. toctree:: + :maxdepth: 2 + + reference/kernels + + +********* +Waveforms +********* + +.. toctree:: + :maxdepth: 1 + + reference/waveform_features + +******************************** +Alternative data representations +******************************** + +.. toctree:: + :maxdepth: 1 + + reference/conversion + +************* +Miscellaneous +************* + +.. toctree:: + :maxdepth: 1 + + reference/neo_tools + reference/utils + reference/pandas_bridge + reference/parallel diff --git a/doc/reference/_spike_train_patterns.rst b/doc/reference/_spike_train_patterns.rst new file mode 100644 index 000000000..47ad8c49e --- /dev/null +++ b/doc/reference/_spike_train_patterns.rst @@ -0,0 +1,12 @@ +======================================= +Detection of synchronous spike patterns +======================================= + +.. toctree:: + :maxdepth: 1 + + cell_assembly_detection + unitary_event_analysis + asset + spade + cubic diff --git a/doc/reference/_spike_train_processing.rst b/doc/reference/_spike_train_processing.rst index 18681efb0..194f60b63 100644 --- a/doc/reference/_spike_train_processing.rst +++ b/doc/reference/_spike_train_processing.rst @@ -1,11 +1,42 @@ -====================== -Spike train processing -====================== +==================================== +Correlative measures on spike trains +==================================== +*********************** +Spike train correlation +*********************** -.. toctree:: - :maxdepth: 1 +.. automodule:: elephant.spike_train_correlation - spike_train_correlation - spike_train_dissimilarity - spike_train_synchrony + +************************* +Spike train dissimilarity +************************* + +.. automodule:: elephant.spike_train_dissimilarity + + +********************* +Spike train synchrony +********************* + +.. automodule:: elephant.spike_train_synchrony + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: cor + :keyprefix: correlation- + :style: unsrt + +.. bibliography:: ../bib/elephant.bib + :labelprefix: ds + :keyprefix: dissimilarity- + :style: unsrt + +.. bibliography:: ../bib/elephant.bib + :labelprefix: syn + :keyprefix: synchrony- + :style: unsrt diff --git a/doc/reference/asset.rst b/doc/reference/asset.rst index c2af18843..973e806d8 100644 --- a/doc/reference/asset.rst +++ b/doc/reference/asset.rst @@ -11,6 +11,6 @@ References ---------- .. bibliography:: ../bib/elephant.bib - :labelprefix: as + :labelprefix: asset :keyprefix: asset- :style: unsrt diff --git a/doc/reference/causality.rst b/doc/reference/causality.rst index 794530a7e..5159a670a 100644 --- a/doc/reference/causality.rst +++ b/doc/reference/causality.rst @@ -3,3 +3,12 @@ Causality measures ================== .. automodule:: elephant.causality.granger + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: gr + :keyprefix: granger- + :style: unsrt diff --git a/doc/reference/cell_assembly_detection.rst b/doc/reference/cell_assembly_detection.rst index 35f3629bf..dc09304c4 100644 --- a/doc/reference/cell_assembly_detection.rst +++ b/doc/reference/cell_assembly_detection.rst @@ -1,6 +1,14 @@ -======================= -Cell assembly detection -======================= +============================= +Cell assembly detection (CAD) +============================= .. automodule:: elephant.cell_assembly_detection - :members: cell_assembly_detection + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: cad + :keyprefix: cad- + :style: unsrt diff --git a/doc/reference/change_point_detection.rst b/doc/reference/change_point_detection.rst index 22189ec69..a93ce89be 100644 --- a/doc/reference/change_point_detection.rst +++ b/doc/reference/change_point_detection.rst @@ -3,4 +3,12 @@ Detection of non-stationary processes ===================================== .. automodule:: elephant.change_point_detection - :members: + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: cpd + :keyprefix: cpd- + :style: unsrt diff --git a/doc/reference/cubic.rst b/doc/reference/cubic.rst index c044999bd..18265b4f9 100644 --- a/doc/reference/cubic.rst +++ b/doc/reference/cubic.rst @@ -3,4 +3,12 @@ Cumulant Based Inference of higher-order Correlation (CuBIC) ============================================================ .. automodule:: elephant.cubic - :members: + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: cubic + :keyprefix: cubic- + :style: unsrt diff --git a/doc/reference/current_source_density.rst b/doc/reference/current_source_density.rst index 6376b466f..53108fe25 100644 --- a/doc/reference/current_source_density.rst +++ b/doc/reference/current_source_density.rst @@ -3,4 +3,25 @@ Current source density analysis =============================== .. automodule:: elephant.current_source_density - :members: + +Keywords +-------- +LFP, CSD, multielectrode, Laminar electrode, Barrel cortex. + + +Citation Policy +--------------- +See `current_source_density_src/README.md +`_ + + +Author Contributions +-------------------- +- Chaitanya Chintaluri (CC) +- Espen Hagen (EH) +- Michał Czerwinski (MC) + +EH implemented the iCSD methods and StandardCSD. +CC implemented the kCSD methods, kCSD1D (MC and CC). +CC and EH developed the interface to Elephant. diff --git a/doc/reference/gpfa.rst b/doc/reference/gpfa.rst index bcc97e346..30c5d7a5f 100644 --- a/doc/reference/gpfa.rst +++ b/doc/reference/gpfa.rst @@ -3,3 +3,12 @@ Gaussian-Process Factor Analysis (GPFA) ======================================= .. automodule:: elephant.gpfa.gpfa + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: gpfa + :keyprefix: gpfa- + :style: unsrt diff --git a/doc/reference/neo_tools.rst b/doc/reference/neo_tools.rst index ff7679694..4c614884d 100644 --- a/doc/reference/neo_tools.rst +++ b/doc/reference/neo_tools.rst @@ -3,4 +3,3 @@ Neo objects utilities ===================== .. automodule:: elephant.neo_tools - :members: diff --git a/doc/reference/pandas_bridge.rst b/doc/reference/pandas_bridge.rst index d73832494..2fb5966e1 100644 --- a/doc/reference/pandas_bridge.rst +++ b/doc/reference/pandas_bridge.rst @@ -3,4 +3,3 @@ Bridge to the pandas library ============================ .. automodule:: elephant.pandas_bridge - :members: diff --git a/doc/reference/phase_analysis.rst b/doc/reference/phase_analysis.rst index 070f40675..c0c2f83c7 100644 --- a/doc/reference/phase_analysis.rst +++ b/doc/reference/phase_analysis.rst @@ -3,4 +3,3 @@ Spike-triggered LFP phase ========================= .. automodule:: elephant.phase_analysis - :members: diff --git a/doc/reference/signal_processing.rst b/doc/reference/signal_processing.rst index e79b1a56b..564650ae4 100644 --- a/doc/reference/signal_processing.rst +++ b/doc/reference/signal_processing.rst @@ -2,12 +2,14 @@ Signal processing ================= -.. testsetup:: - - import numpy as np - from quantities import mV, s, Hz - import neo - from elephant.signal_processing import zscore .. automodule:: elephant.signal_processing - :members: + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: sig + :keyprefix: signal- + :style: unsrt diff --git a/doc/reference/spade.rst b/doc/reference/spade.rst index 3b071d7f6..0e9164bf7 100644 --- a/doc/reference/spade.rst +++ b/doc/reference/spade.rst @@ -3,3 +3,12 @@ Spike Pattern Detection and Evaluation (SPADE) ============================================== .. automodule:: elephant.spade + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: spade + :keyprefix: spade- + :style: unsrt diff --git a/doc/reference/spectral.rst b/doc/reference/spectral.rst index 2b88efab5..c21b55df5 100644 --- a/doc/reference/spectral.rst +++ b/doc/reference/spectral.rst @@ -3,4 +3,3 @@ Spectral analysis ================= .. automodule:: elephant.spectral - :members: diff --git a/doc/reference/spike_train_correlation.rst b/doc/reference/spike_train_correlation.rst deleted file mode 100644 index ed83708e1..000000000 --- a/doc/reference/spike_train_correlation.rst +++ /dev/null @@ -1,11 +0,0 @@ -======================= -Spike train correlation -======================= - -.. testsetup:: - - from quantities import Hz, s, ms - from elephant.spike_train_correlation import corrcoef - - -.. automodule:: elephant.spike_train_correlation diff --git a/doc/reference/spike_train_dissimilarity.rst b/doc/reference/spike_train_dissimilarity.rst deleted file mode 100644 index d0cffe957..000000000 --- a/doc/reference/spike_train_dissimilarity.rst +++ /dev/null @@ -1,6 +0,0 @@ -========================= -Spike train dissimilarity -========================= - - -.. automodule:: elephant.spike_train_dissimilarity diff --git a/doc/reference/spike_train_generation.rst b/doc/reference/spike_train_generation.rst index 2569b6d7e..2b0d4b738 100644 --- a/doc/reference/spike_train_generation.rst +++ b/doc/reference/spike_train_generation.rst @@ -1,11 +1,6 @@ -================================= -Stochastic spike train generation -================================= - -.. testsetup:: - - from elephant.spike_train_generation import homogeneous_poisson_process, homogeneous_gamma_process +====================== +Spike train generation +====================== .. automodule:: elephant.spike_train_generation - :members: diff --git a/doc/reference/spike_train_surrogates.rst b/doc/reference/spike_train_surrogates.rst index e7af0d8ee..a3ebcbdf6 100644 --- a/doc/reference/spike_train_surrogates.rst +++ b/doc/reference/spike_train_surrogates.rst @@ -3,10 +3,13 @@ Spike train surrogates ====================== -.. testsetup:: +.. automodule:: elephant.spike_train_surrogates - from elephant.spike_train_surrogates import shuffle_isis, randomise_spikes, jitter_spikes, dither_spikes, dither_spike_train +References +---------- -.. automodule:: elephant.spike_train_surrogates - :members: +.. bibliography:: ../bib/elephant.bib + :labelprefix: sr + :keyprefix: surrogates- + :style: unsrt diff --git a/doc/reference/spike_train_synchrony.rst b/doc/reference/spike_train_synchrony.rst deleted file mode 100644 index c59963727..000000000 --- a/doc/reference/spike_train_synchrony.rst +++ /dev/null @@ -1,14 +0,0 @@ -===================== -Spike train synchrony -===================== - -.. automodule:: elephant.spike_train_synchrony - - -References ----------- - -.. bibliography:: ../bib/elephant.bib - :labelprefix: syn - :keyprefix: synchrony- - :style: unsrt diff --git a/doc/reference/sta.rst b/doc/reference/sta.rst index 41e0fb9a5..be73f2bf0 100644 --- a/doc/reference/sta.rst +++ b/doc/reference/sta.rst @@ -3,4 +3,3 @@ Spike-triggered average ======================= .. automodule:: elephant.sta - :members: diff --git a/doc/reference/unitary_event_analysis.rst b/doc/reference/unitary_event_analysis.rst index 4a40eaa31..ff7d2705b 100644 --- a/doc/reference/unitary_event_analysis.rst +++ b/doc/reference/unitary_event_analysis.rst @@ -1,6 +1,6 @@ -====================== -Unitary Event Analysis -====================== +=========================== +Unitary Event Analysis (UE) +=========================== .. automodule:: elephant.unitary_event_analysis diff --git a/doc/reference/waveform_features.rst b/doc/reference/waveform_features.rst index 1d37fa2df..10ebcbf6c 100644 --- a/doc/reference/waveform_features.rst +++ b/doc/reference/waveform_features.rst @@ -3,4 +3,12 @@ Waveform features ================= .. automodule:: elephant.waveform_features - :members: + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: wf + :keyprefix: waveforms- + :style: unsrt diff --git a/doc/release_notes.rst b/doc/release_notes.rst index 37723372d..3e279d2e3 100644 --- a/doc/release_notes.rst +++ b/doc/release_notes.rst @@ -1,10 +1,10 @@ -************* +============= Release Notes -************* +============= Elephant 0.9.0 release notes -============================ +**************************** This release is titled to accompany the [2nd Elephant User Workshop](https://www.humanbrainproject.eu/en/education/participatecollaborate/infrastructure-events-trainings/2nd-elephant-user-workshop/) @@ -72,7 +72,7 @@ Bug fixes Elephant 0.8.0 release notes -============================ +**************************** New features ------------ @@ -99,7 +99,7 @@ Breaking changes * Naming convention changes (`binsize` -> `bin_size`, etc.) in almost all Elephant functions (https://github.com/NeuralEnsemble/elephant/pull/316). Elephant 0.7.0 release notes -============================ +**************************** Breaking changes ---------------- @@ -145,7 +145,7 @@ Performance Elephant 0.6.4 release notes -============================ +**************************** This release has been made for the "1st Elephant User Workshop" (https://www.humanbrainproject.eu/en/education/participatecollaborate/infrastructure-events-trainings/1st-elephant-user-workshop-accelerate-structured-and-reproducibl). @@ -177,7 +177,7 @@ Improvements Elephant 0.6.3 release notes -============================ +**************************** July 22nd 2019 The release v0.6.3 is mostly about improving maintenance. @@ -200,7 +200,7 @@ Other changes * Single VERSION file (https://github.com/NeuralEnsemble/elephant/pull/231) Elephant 0.6.2 release notes -============================ +**************************** April 23rd 2019 New functions @@ -215,7 +215,7 @@ Other changes Elephant 0.6.1 release notes -============================ +**************************** April 1st 2019 New functions @@ -233,7 +233,7 @@ Other changes Elephant 0.6.0 release notes -============================ +**************************** October 12th 2018 New functions @@ -251,7 +251,7 @@ Other changes Elephant 0.5.0 release notes -============================ +**************************** April 4nd 2018 New functions @@ -271,7 +271,7 @@ Other changes Elephant 0.4.3 release notes -============================ +**************************** March 2nd 2018 Other changes @@ -281,7 +281,7 @@ Other changes Elephant 0.4.2 release notes -============================ +**************************** March 1st 2018 New functions @@ -307,7 +307,7 @@ Other changes Elephant 0.4.1 release notes -============================ +**************************** March 23rd 2017 Other changes @@ -316,7 +316,7 @@ Other changes Elephant 0.4.0 release notes -============================ +**************************** March 22nd 2017 New functions @@ -342,7 +342,7 @@ Other changes Elephant 0.3.0 release notes -============================ +**************************** April 12st 2016 New functions @@ -371,7 +371,7 @@ Other changes Elephant 0.2.1 release notes -============================ +**************************** February 18th 2016 Other changes @@ -380,7 +380,7 @@ Minor bug fixes. Elephant 0.2.0 release notes -============================ +**************************** September 22nd 2015 New functions diff --git a/doc/style_guide.rst b/doc/style_guide.rst index 0cbd5ba07..788a82828 100644 --- a/doc/style_guide.rst +++ b/doc/style_guide.rst @@ -1,4 +1,4 @@ -.. _style_guide: +:orphan: ******************************** Coding Style Guide with Examples diff --git a/doc/tutorials.rst b/doc/tutorials.rst index ff4abdcf3..ff7bef263 100644 --- a/doc/tutorials.rst +++ b/doc/tutorials.rst @@ -74,3 +74,16 @@ Additional .. image:: https://mybinder.org/badge.svg :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master?filepath=doc/tutorials/parallel.ipynb + +.. + Index the notebooks in a hidden toctree to avoid sphinx warnings. + +.. toctree:: + :hidden: + + tutorials/asset.ipynb + tutorials/gpfa.ipynb + tutorials/parallel.ipynb + tutorials/statistics.ipynb + tutorials/unitary_event_analysis.ipynb + tutorials/granger_causality.ipynb diff --git a/elephant/__init__.py b/elephant/__init__.py index e5009763c..4795583b6 100644 --- a/elephant/__init__.py +++ b/elephant/__init__.py @@ -2,7 +2,7 @@ """ Elephant is a package for the analysis of neurophysiology data, based on Neo. -:copyright: Copyright 2014-2019 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index 653962c19..2cf1f7986 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -8,7 +8,7 @@ ----------------------------------------------- .. autosummary:: - :toctree: toctree/asset/ + :toctree: _toctree/asset/ ASSET @@ -17,7 +17,7 @@ ------------------------- .. autosummary:: - :toctree: toctree/asset/ + :toctree: _toctree/asset/ synchronous_events_intersection synchronous_events_difference @@ -42,59 +42,77 @@ Examples -------- +In this example we -0) Create `ASSET` class object that holds spike trains. + * simulate two noisy synfire chains; + * shuffle the neurons to destroy visual appearance; + * run ASSET analysis to recover the original neurons arrangement. - `ASSET` requires at least one argument - a list of spike trains. If - `spiketrains_y` is not provided, the same spike trains are used to build an - intersection matrix with. +1. Simulate two noise synfire chains, shuffle the neurons to destroy the + pattern visually, and store shuffled activations in neo.SpikeTrains. >>> import neo >>> import numpy as np >>> import quantities as pq - >>> from elephant import asset + >>> np.random.seed(10) + >>> spiketrain = np.linspace(0, 50, num=10) + >>> np.random.shuffle(spiketrain) + >>> spiketrains = np.c_[spiketrain, spiketrain + 100] + >>> spiketrains += np.random.random_sample(spiketrains.shape) * 5 + >>> spiketrains = [neo.SpikeTrain(st, units='ms', t_stop=1 * pq.s) + ... for st in spiketrains] + +2. Create `ASSET` class object that holds spike trains. + + `ASSET` requires at least one argument - a list of spike trains. If + `spiketrains_y` is not provided, the same spike trains are used to build an + intersection matrix with. - >>> spiketrains = [ - ... neo.SpikeTrain([start, start + 6] * (3 * pq.ms) + 10 * pq.ms, - ... t_stop=60 * pq.ms) - ... for _ in range(3) - ... for start in range(3) - ... ] - >>> asset_obj = asset.ASSET(spiketrains, bin_size=3*pq.ms, verbose=False) + >>> from elephant import asset + >>> asset_obj = asset.ASSET(spiketrains, bin_size=3*pq.ms) -1) Build the intersection matrix `imat`: +3. Build the intersection matrix `imat`: >>> imat = asset_obj.intersection_matrix() -2) Estimate the probability matrix `pmat`, using the analytical method: +4. Estimate the probability matrix `pmat`, using the analytical method: >>> pmat = asset_obj.probability_matrix_analytical(imat, - ... kernel_width=9*pq.ms) + ... kernel_width=50*pq.ms) -3) Compute the joint probability matrix `jmat`, using a suitable filter: +5. Compute the joint probability matrix `jmat`, using a suitable filter: >>> jmat = asset_obj.joint_probability_matrix(pmat, filter_shape=(5, 1), ... n_largest=3) -4) Create the masked version of the intersection matrix, `mmat`, from `pmat` +6. Create the masked version of the intersection matrix, `mmat`, from `pmat` and `jmat`: >>> mmat = asset_obj.mask_matrices([pmat, jmat], thresholds=.9) -5) Cluster significant elements of imat into diagonal structures: +7. Cluster significant elements of imat into diagonal structures: - >>> cmat = asset_obj.cluster_matrix_entries(mmat, max_distance=3, + >>> cmat = asset_obj.cluster_matrix_entries(mmat, max_distance=11, ... min_neighbors=3, stretch=5) -6) Extract sequences of synchronous events: +9. Extract sequences of synchronous events: >>> sses = asset_obj.extract_synchronous_events(cmat) -The ASSET found 2 sequences of synchronous events: +The ASSET found the following sequences of synchronous events: + +>>> sses +{1: {(36, 2): {5}, + (37, 4): {1}, + (40, 6): {4}, + (41, 7): {8}, + (43, 9): {2}, + (47, 14): {7}, + (48, 15): {0}, + (50, 17): {9}}} - >>> from pprint import pprint - >>> pprint(sses) - {1: {(9, 3): {0, 3, 6}, (10, 4): {1, 4, 7}, (11, 5): {8, 2, 5}}} +To visualize them, refer to Viziphant documentation and an example plot +:func:`viziphant.asset.plot_synchronous_events`. """ from __future__ import division, print_function, unicode_literals @@ -240,18 +258,18 @@ def _transactions(spiketrains, bin_size, t_start, t_stop, ids=None): time segment `[t_start, t_start+bin_size]`. If None, takes the value of `spiketrain.t_start`, common for all input `spiketrains` (raises ValueError if it's not the case). - Default: None. + Default: None t_stop : pq.Quantity The ending time. Only spikes occurring at times `t < t_stop` are considered. If None, takes the value of `spiketrain.t_stop`, common for all input `spiketrains` (raises ValueError if it's not the case). - Default: None. + Default: None ids : list of int, optional List of spike train IDs. If None, the IDs `0` to `N-1` are used, where `N` is the number of input spike trains. - Default: None. + Default: None Returns ------- @@ -1296,7 +1314,7 @@ def synchronous_events_intersection(sse1, sse2, intersection='linkwise'): of synchronous events as values (see above). intersection : {'pixelwise', 'linkwise'}, optional The type of intersection to perform among the two SSEs (see above). - Default: 'linkwise'. + Default: 'linkwise' Returns ------- @@ -1365,7 +1383,7 @@ def synchronous_events_difference(sse1, sse2, difference='linkwise'): difference : {'pixelwise', 'linkwise'}, optional The type of difference to perform between `sse1` and `sse2` (see above). - Default: 'linkwise'. + Default: 'linkwise' Returns ------- @@ -1732,16 +1750,16 @@ class ASSET(object): respectively. If None, the attribute `t_start` of the spike trains is used (if the same for all spike trains). - Default: None. + Default: None t_stop_i, t_stop_j : pq.Quantity, optional The stop time of the binning for the first and second axes, respectively. If None, the attribute `t_stop` of the spike trains is used (if the same for all spike trains). - Default: None. + Default: None verbose : bool, optional If True, print messages and show progress bar. - Default: True. + Default: True Raises @@ -1856,7 +1874,7 @@ def intersection_matrix(self, normalization=None): * 'intersection': `len(intersection(s_i, s_j))` * 'mean': `sqrt(len(s_1) * len(s_2))` * 'union': `len(union(s_i, s_j))` - Default: None. + Default: None Returns ------- @@ -1917,7 +1935,7 @@ def probability_matrix_montecarlo(self, n_surrogates, imat=None, :func:`spike_train_surrogates.surrogates` documentation for more information about each surrogate method. Note that some of these methods need `surrogate_dt` parameter, others ignore it. - Default: 'dither_spike_train'. + Default: 'dither_spike_train' surrogate_dt : pq.Quantity, optional For surrogate methods shifting spike times randomly around their original time ('dither_spike_train', 'dither_spikes') or replacing @@ -1925,7 +1943,7 @@ def probability_matrix_montecarlo(self, n_surrogates, imat=None, `surrogate_dt` represents the size of that shift (window). For other methods, `surrogate_dt` is ignored. If None, it's set to `self.bin_size * 5`. - Default: None. + Default: None Returns ------- @@ -2040,11 +2058,11 @@ def probability_matrix_analytical(self, imat=None, `spiketrains[i]`. If 'estimate', firing rates are estimated by simple boxcar kernel convolution, with the specified `kernel_width`. - Default: 'estimate'. + Default: 'estimate' kernel_width : pq.Quantity, optional The total width of the kernel used to estimate the rate profiles when `firing_rates` is 'estimate'. - Default: 100 * pq.ms. + Default: 100 * pq.ms Returns ------- @@ -2182,6 +2200,8 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, significant value in `pmat` (extreme case: `pmat[i, j] = 1`) yields joint significance of itself and its neighbors. Default: 1e-5 +<<<<<<< HEAD:elephant/asset.py +======= precision : {'float', 'double'}, optional Single or double floating-point precision for the resulting `jmat` matrix. @@ -2217,6 +2237,7 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, resulting joint prob. matrix values are outside of the acceptable range ``[-tolerance, 1.0 + tolerance]``. Default: 1e-5 +>>>>>>> master:elephant/asset/asset.py Returns ------- @@ -2456,13 +2477,13 @@ def extract_synchronous_events(self, cmat, ids=None): Parameters ---------- - cmat: (n,n) np.ndarray + cmat : (n,n) np.ndarray The cluster matrix, the output of :func:`ASSET.cluster_matrix_entries`. ids : list, optional A list of spike train IDs. If provided, `ids[i]` is the identity of `spiketrains[i]`. If None, the IDs `0,1,...,n-1` are used. - Default: None. + Default: None Returns ------- diff --git a/elephant/causality/granger.py b/elephant/causality/granger.py index a6a68e89e..7a1b184e6 100644 --- a/elephant/causality/granger.py +++ b/elephant/causality/granger.py @@ -1,15 +1,11 @@ # -*- coding: utf-8 -*- """ -.. current_module elephant.causality - -Overview --------- This module provides function to estimate causal influences of signals on each other. Granger causality -~~~~~~~~~~~~~~~~~ +***************** Granger causality is a method to determine causal influence of one signal on another based on autoregressive modelling. It was developed by Nobel prize laureate Clive Granger and has been adopted in various numerical fields ever @@ -20,14 +16,14 @@ to Granger cause the other signal. Limitations -+++++++++++ +----------- The user must be mindful of the method's limitations, which are assumptions of covariance stationary data, linearity imposed by the underlying autoregressive modelling as well as the fact that the variables not included in the model will not be accounted for :cite:`granger-Seth07_1667`. Implementation -++++++++++++++ +-------------- The mathematical implementation of Granger causality methods in this module closely follows :cite:`granger-Ding06_0608035`. @@ -42,7 +38,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. autosummary:: - :toctree: toctree/causality/ + :toctree: _toctree/causality/ pairwise_granger conditional_granger @@ -59,16 +55,6 @@ :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master ?filepath=doc/tutorials/granger_causality.ipynb - -References ----------- - -.. bibliography:: ../bib/elephant.bib - :labelprefix: gr - :keyprefix: granger- - :style: unsrt - - :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -158,11 +144,11 @@ def _lag_covariances(signals, dimension, max_lag): Parameters ---------- - signals: np.ndarray + signals : np.ndarray time series data dimension : int number of time series - max_lag: int + max_lag : int maximal time lag to be considered Returns @@ -284,7 +270,7 @@ def _vector_arm(signals, dimension, order): Returns ------- - coeffs: np.ndarray + coeffs : np.ndarray coefficients of the autoregressive model ry covar_mat : np.ndarray @@ -336,7 +322,7 @@ def _optimal_vector_arm(signals, dimension, max_order, Returns ------- - optimal_coeffs: np.ndarray + optimal_coeffs : np.ndarray coefficients of the autoregressive model optimal_cov_mat : np.ndarray covariance matrix of @@ -386,7 +372,7 @@ def pairwise_granger(signals, max_order, information_criterion='aic'): A function to compute the information criterion: `bic` for Bayesian information_criterion, `aic` for Akaike information criterion, - Default: 'aic'. + Default: 'aic' Returns ------- @@ -559,7 +545,7 @@ def conditional_granger(signals, max_order, information_criterion='aic'): A function to compute the information criterion: `bic` for Bayesian information_criterion, `aic` for Akaike information criterion, - Default: 'aic'. + Default: 'aic' Returns ------- diff --git a/elephant/cell_assembly_detection.py b/elephant/cell_assembly_detection.py index 10aa45401..d225d7296 100644 --- a/elephant/cell_assembly_detection.py +++ b/elephant/cell_assembly_detection.py @@ -1,8 +1,8 @@ """ -CAD [1] is a method aimed to capture structures of higher-order correlation in -massively parallel spike trains. In particular, it is able to extract -patterns of spikes with arbitrary configuration of time lags (time interval -between spikes in a pattern), and at multiple time scales, +CAD :cite:`cad-Russo2017_e19428` is a method aimed to capture structures of +higher-order correlation in massively parallel spike trains. In particular, it +is able to extract patterns of spikes with arbitrary configuration of time lags +(time interval between spikes in a pattern), and at multiple time scales, e.g. from synchronous patterns to firing rate co-modulations. CAD consists of a statistical parametric testing done on the level of pairs @@ -12,59 +12,57 @@ hypothesis of independence, and then the significant pairs are agglomerated into higher order patterns. -The method was published in Russo et al. 2017 [1]. The original -code is in Matlab language. - Given a list of discretized (binned) spike trains by a given temporal scale (bin_size), assumed to be recorded in parallel, the CAD analysis can be applied as demonstrated in this short toy example of 5 parallel spike trains that exhibit fully synchronous events of order 5. +.. autosummary:: + :toctree: _toctree/cell_assembly_detection + + cell_assembly_detection + + +Visualization +------------- +Visualization of CAD method is covered in Viziphant +:func:`viziphant.patterns.plot_patterns` + + +See Also +-------- +elephant.spade.spade : advanced synchronous patterns detection + Examples -------- ->>> import matplotlib.pyplot as plt ->>> import elephant.conversion as conv ->>> import elephant.spike_train_generation >>> import quantities as pq >>> import numpy as np ->>> import elephant.cell_assembly_detection as cad +>>> from elephant.cell_assembly_detection import cell_assembly_detection +>>> from elephant.spike_train_generation import compound_poisson_process +>>> from elephant.conversion import BinnedSpikeTrain + +Generate correlated data and bin it with a bin_size of 10ms. + >>> np.random.seed(30) ->>> # Generate correlated data and bin it with a bin_size of 10ms ->>> sts = elephant.spike_train_generation.cpp( ->>> rate=15*pq.Hz, A=[0]+[0.95]+[0]*4+[0.05], t_stop=10*pq.s) ->>> bin_size = 10*pq.ms ->>> spM = conv.BinnedSpikeTrain(sts, bin_size=bin_size) ->>> # Call of the method ->>> patterns = cad.cell_assembly_detection(spM=spM, max_lag=2)[0] ->>> # Plotting ->>> plt.figure() ->>> for neu in patterns['neurons']: ->>> if neu == 0: ->>> plt.plot( ->>> patterns['times']*bin_size, [neu]*len(patterns['times']), ->>> 'ro', label='pattern') ->>> else: ->>> plt.plot( ->>> patterns['times']*bin_size, [neu] * len(patterns['times']), ->>> 'ro') ->>> # Raster plot of the data ->>> for st_idx, st in enumerate(sts): ->>> if st_idx == 0: ->>> plt.plot(st.rescale(pq.ms), [st_idx] * len(st), 'k.', ->>> label='spikes') ->>> else: ->>> plt.plot(st.rescale(pq.ms), [st_idx] * len(st), 'k.') ->>> plt.ylim([-1, len(sts)]) ->>> plt.xlabel('time (ms)') ->>> plt.ylabel('neurons ids') ->>> plt.legend() ->>> plt.show() - -References ----------- -[1] Russo, E., & Durstewitz, D. (2017). -Cell assemblies at multiple time scales with arbitrary lag constellations. -Elife, 6. +>>> spiketrains = compound_poisson_process(rate=15*pq.Hz, +... amplitude_distribution=[0, 0.95, 0, 0, 0, 0, 0.05], t_stop=5*pq.s) +>>> bst = BinnedSpikeTrain(spiketrains, bin_size=10 * pq.ms) +>>> bst.rescale('ms') + +Call of the method. + +>>> patterns = cell_assembly_detection(bst, max_lag=2) +>>> patterns[0] +{'neurons': [0, 2], + 'lags': array([0.]) * ms, + 'pvalue': [5.3848138041122556e-05], + 'times': array([ 90., 160., 170., 550., 790., 910., 930., 1420., 1470., + 1480., 1650., 2030., 2220., 2570., 3130., 3430., 3480., 3610., + 3800., 3830., 3930., 4080., 4560., 4600., 4670.]) * ms, + 'signature': [[1, 83], [2, 25]]} + +Refer to the Viziphant documentation regarding the visualization of this +example. """ @@ -73,6 +71,7 @@ import copy import math import time +import warnings import numpy as np from scipy.stats import f @@ -93,15 +92,14 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, max_spikes=np.inf, significance_pruning=True, subgroup_pruning=True, same_configuration_pruning=False, - bool_times_format=False, verbose=False): - + bool_times_format=None, verbose=False): """ - The function performs the CAD analysis for the binned (discretized) spike - trains given in input. The method looks for candidate - significant patterns with lags (number of bins between successive spikes - in the pattern) going from `-max_lag` to `max_lag` (second parameter of the - function). Thus, between two successive spikes in the pattern there can - be at most `max_lag`*`bin_size` units of time. + Perform the CAD analysis :cite:`cad-Russo2017_e19428` for the binned + (discretized) spike trains given in the input. The method looks for + candidate significant patterns with lags (number of bins between successive + spikes in the pattern) ranging from `-max_lag` to `max_lag` (the second + parameter of the function). Thus, between two successive spikes in the + pattern there can be at most `max_lag`*`bin_size` units of time. The method agglomerates pairs of units (or a unit and a preexisting assembly), tests their significance by a statistical test @@ -127,48 +125,46 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, reference_lag : int, optional Reference lag (in bins) for the non-stationarity correction in the statistical test. - Default: 2. + Default: 2 alpha : float, optional Significance level for the statistical test. - Default: 0.05. + Default: 0.05 min_occurrences : int, optional Minimal number of occurrences required for an assembly (all assemblies, even if significant, with fewer occurrences than min_occurrences are discarded). - Default: 0. + Default: 0 size_chunks : int, optional Size (in bins) of chunks in which the spike trains are divided to compute the variance (to reduce non stationarity effects on variance estimation). - Default: 100. + Default: 100 max_spikes : int, optional Maximal assembly order (the algorithm will return assemblies composed of maximum `max_spikes` elements). - Default: `np.inf`. + Default: `np.inf` significance_pruning : bool, optional If True, the method performs significance pruning among the detected assemblies. - Default: True. + Default: True subgroup_pruning : bool, optional If True, the method performs subgroup pruning among the detected assemblies. - Default: True. + Default: True same_configuration_pruning : bool, optional If True, performs pruning (not present in the original code and more efficient), not testing assemblies already formed if they appear in the very same configuration. - Default: False. + Default: False bool_times_format : bool, optional - If True, the activation time series is a list of 0/1 elements, where - 1 indicates the first spike of the pattern. - Otherwise, the activation times of the assemblies are indicated by the - indices of the bins in which the first spike of the pattern - is happening. - Default: False. + .. deprecated:: 0.10.0 + Has no effect, the returning 'times' are always a quantity array + specifying the pattern spike times. + Default: None verbose : bool, optional Regulates the number of prints given by the method. If true all prints are given, otherwise the method does give any prints. - Default: False. + Default: False Returns ------- @@ -179,7 +175,7 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, 'neurons' : list Vector of units taking part to the assembly (unit order correspond to the agglomeration order). - 'lag' : list + 'lag' : pq.Quantity Vector of time lags. `lag[z]` is the activation delay between `neurons[1]` and `neurons[z+1]`. @@ -187,13 +183,9 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, Vector containing p-values. `pvalue[z]` is the p-value of the statistical test between performed adding `neurons[z+1]` to the `neurons[1:z]`. - 'times' : list - Assembly activation time. It reports how many times the - complete assembly activates in that bin. Time always refers to the - activation of the first listed assembly element (`neurons[1]`), - that doesn't necessarily corresponds to the first unit firing. - The format is identified by the variable `bool_times_format`. - 'signature' : list of list + 'times' : pq.Quantity + Assembly activation times in the units of `binned_spiketrain`. + 'signature' : np.ndarray Array of two entries `(z,c)`. The first is the number of neurons participating in the assembly (size), and the second is number of assembly occurrences. @@ -202,7 +194,7 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, ------ TypeError If `binned_spiketrain` is not an instance of - `elephant.conv.BinnedSpikeTrain`. + `elephant.conversion.BinnedSpikeTrain`. ValueError If the parameters are out of bounds. @@ -210,30 +202,6 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, ----- Alias: cad - References - ---------- - [1] Russo, E., & Durstewitz, D. (2017). Cell assemblies at multiple time - scales with arbitrary lag constellations. Elife, 6. - - Examples - -------- - >>> import elephant.conversion as conv - >>> import elephant.spike_train_generation - >>> import quantities as pq - >>> import numpy as np - >>> import elephant.cell_assembly_detection as cad - ... - >>> np.random.seed(30) - ... - >>> # Generate correlated data and bin it with a bin_size of 10ms - >>> sts = elephant.spike_train_generation.cpp( - >>> rate=15*pq.Hz, A=[0]+[0.95]+[0]*4+[0.05], t_stop=10*pq.s) - >>> bin_size = 10*pq.ms - >>> spM = conv.BinnedSpikeTrain(sts, bin_size=bin_size) - ... - >>> # Call of the method - >>> patterns = cad.cell_assembly_detection(spM=spM, max_lag=2)[0] - """ initial_time = time.time() @@ -245,6 +213,15 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, size_chunks=size_chunks, max_spikes=max_spikes) + if bool_times_format is not None: + warnings.warn("'bool_times_format' is deprecated and has no effect; " + "the returning 'times' are always a quantity array " + "specifying the pattern spike times. Set this parameter " + "to None.", DeprecationWarning) + + bin_size = binned_spiketrain.bin_size + t_start = binned_spiketrain.t_start + # transform the binned spiketrain into array binned_spiketrain = binned_spiketrain.to_array() @@ -343,9 +320,7 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, # the algorithm will return assemblies composed by # maximum max_spikes elements if verbose: - print() - print('Testing on higher order assemblies...') - print() + print('\nTesting on higher order assemblies...\n') # keep the count of the current size of the assembly current_size_agglomeration = 2 @@ -461,15 +436,15 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, assembly = _subgroup_pruning_step(pre_pruning_assembly=assembly) # Reformat of the activation times - if not bool_times_format: - for pattern in assembly: - pattern['times'] = np.where(pattern['times'] > 0)[0] + for pattern in assembly: + times = np.where(pattern['times'] > 0)[0] * bin_size + t_start + pattern['times'] = times + pattern['lags'] = pattern['lags'] * bin_size + pattern['signature'] = np.array(pattern['signature'], dtype=np.int32) # Give as output only the maximal groups if verbose: - print() - print('Giving outputs of the method...') - print() + print('\nGiving outputs of the method...\n') print('final_assembly') for item in assembly: print(item['neurons'], @@ -478,8 +453,7 @@ def cell_assembly_detection(binned_spiketrain, max_lag, reference_lag=2, # Time needed for the computation if verbose: - print() - print('time', time.time() - initial_time) + print('\ntime', time.time() - initial_time) return assembly @@ -564,9 +538,9 @@ def _assert_same_pattern(item_candidate, existing_patterns, max_lag): item_candidate : list of list with two components in the first component there are the neurons involved in the assembly, in the second there are the correspondent lags - existing_patterns: list + existing_patterns : list list of the already significant patterns - max_lag: int + max_lag : int maximum lag to be tested Returns @@ -607,9 +581,9 @@ def _test_pair(ensemble, spiketrain2, n2, max_lag, size_chunks, reference_lag, on variance estimation) reference_lag : int lag of reference; if zero or negative reference lag=-l - existing_patterns: list + existing_patterns : list list of the already significant patterns - same_configuration_pruning: bool + same_configuration_pruning : bool if True (not present in the original code and more efficient), does not test assemblies already formed if they appear in the very same configuration @@ -1147,7 +1121,7 @@ def _raise_errors(binned_spiketrain, max_lag, alpha, min_occurrences, ---------- binned_spiketrain : BinnedSpikeTrain object binned spike trains containing data to be analysed - max_lag: int + max_lag : int maximal lag to be tested. For a binning dimension of bin_size the method will test all pairs configurations with a time shift between -max_lag and max_lag diff --git a/elephant/change_point_detection.py b/elephant/change_point_detection.py index fb24763db..cc09dd3a7 100644 --- a/elephant/change_point_detection.py +++ b/elephant/change_point_detection.py @@ -1,48 +1,42 @@ # -*- coding: utf-8 -*- """ -This algorithm determines if a spike train `spk` can be considered as -stationary process (constant firing rate) or not as stationary process (i.e. -presence of one or more points at which the rate increases or decreases). In -case of non-stationarity, the output is a list of detected Change Points (CPs). -Essentially, a det of two-sided window of width `h` (`_filter(t, h, spk)`) -slides over the spike train within the time `[h, t_final-h]`. This generates a -`_filter_process(time_step, h, spk)` that assigns at each time `t` the -difference between a spike lying in the right and left window. If at any time -`t` this difference is large 'enough' is assumed the presence of a rate Change -Point in a neighborhood of `t`. A threshold `test_quantile` for the maximum of -the filter_process (max difference of spike count between the left and right -window) is derived based on asymptotic considerations. The procedure is -repeated for an arbitrary set of windows, with different size `h`. +The Change point detection algorithm :cite:`cpd-Messer2014_2027` determines if +a spike train `spiketrain` can be considered as a stationary process (constant +firing rate) or not as stationary process (i.e. presence of one or more points +at which the rate increases or decreases). In case of non-stationarity, the +output is a list of detected Change Points (CPs). + +Essentially, a set of two-sided windows of width `h` +(`_filter(t, h, spiketrain)`) slides over the spike train within the time +`[h, t_final-h]`. This generates a `_filter_process(time_step, h, spiketrain)` +that assigns at each time `t` the difference between a spike lying in the right +and left windows. If at any time `t` this difference is large 'enough', the +presence of a rate Change Point in a neighborhood of `t` is assumed. A +threshold `test_quantile` for the maximum of the filter_process (max +difference of spike count between the left and right windows) is derived based +on asymptotic considerations. The procedure is repeated for an arbitrary set of +windows with different sizes `h`. + +.. autosummary:: + :toctree: _toctree/change_point_detection + + multiple_filter_test + empirical_parameters Examples -------- -The following applies multiple_filter_test to a spike trains. - - >>> import quantities as pq - >>> import neo - >>> from elephant.change_point_detection import multiple_filter_test - ... - >>> test_array = [1.1,1.2,1.4, 1.6,1.7,1.75,1.8,1.85,1.9,1.95] - >>> st = neo.SpikeTrain(test_array, units='s', t_stop = 2.1) - >>> window_size = [0.5]*pq.s - >>> t_fin = 2.1*pq.s - >>> alpha = 5.0 - >>> num_surrogates = 10000 - >>> change_points = multiple_filter_test(window_size, st, t_fin, alpha, - ... num_surrogates, time_step = 0.5*pq.s) - -References ----------- -Messer, M., Kirchner, M., Schiemann, J., Roeper, J., Neininger, R., & -Schneider, G. (2014). A multiple filter test for the detection of rate changes -in renewal processes with varying variance. The Annals of Applied Statistics, -8(4),2027-2067. +>>> import quantities as pq +>>> from elephant.change_point_detection import multiple_filter_test +>>> spike_times = [1.1, 1.2, 1.4, 1.6, 1.7, 1.75, 1.8, 1.9, 1.95] * pq.s +>>> change_points = multiple_filter_test(window_sizes=[0.5] * pq.s, +... spiketrain=spike_times, t_final=2.1 * pq.s, alpha=5, n_surrogates=100, +... time_step=0.1 * pq.s) +[[array(1.5) * s]] Original code ------------- -Adapted from the published R implementation: -DOI: 10.1214/14-AOAS782SUPP;.r +Adapted from the published R implementation: DOI: 10.1214/14-AOAS782SUPP;.r """ @@ -61,51 +55,61 @@ @deprecated_alias(dt='time_step') def multiple_filter_test(window_sizes, spiketrain, t_final, alpha, - n_surrogates, test_quantile=None, test_param=None, - time_step=None): + n_surrogates=1000, test_quantile=None, + test_param=None, time_step=None): """ Detects change points. - This function returns the detected change points, that correspond to the - maxima of the `_filter_processes`. These are the processes generated by - sliding the windows of step `time_step`; at each step the difference - between spike on the right and left window is calculated. + This function returns the detected change points that corresponds to the + maxima of the *filter processes* - the processes generated by sliding + windows of step `time_step`; at each step the difference between spikes on + the right and left windows is calculated. Parameters ---------- - window_sizes : list of quantity objects + window_sizes : list of pq.Quantity list that contains windows sizes - spiketrain : neo.SpikeTrain, numpy array or list - spiketrain objects to analyze - t_final : quantity - final time of the spike train which is to be analysed + spiketrain : neo.SpikeTrain or pq.Quantity + A spiketrain object to analyze. + t_final : pq.Quantity + The final time of the spike train which is to be analysed alpha : float - alpha-quantile in range [0, 100] for the set of maxima of the limit + Alpha-quantile in range [0, 100] for the set of maxima of the limit processes - n_surrogates : integer - numbers of simulated limit processes - test_quantile : float - threshold for the maxima of the filter derivative processes, if any + n_surrogates : int, optional + The number of simulated limit processes. + Default: 1000 + test_quantile : float or None, optional + The threshold for the maxima of the filter derivative processes; if any of these maxima is larger than this value, it is assumed the - presence of a cp at the time corresponding to that maximum - time_step : quantity - resolution, time step at which the windows are slided - test_param : np.array of shape (3, num of window), + presence of a change point (cp) at the time corresponding to that + maximum. + If None, will be set according to the :func:`empirical_parameters`. + Default: None + test_param : (3, num. of windows) np.ndarray or None, optional first row: list of `h`, second and third rows: empirical means and - variances of the limit process correspodning to `h`. This will be - used to normalize the `filter_process` in order to give to the + variances of the limit process corresponding to `h`. This will be + used to normalize the *filter processes* in order to give to the every maximum the same impact on the global statistic. + If None, will be set according to the :func:`empirical_parameters`. + Default: None + time_step : pq.Quantity or None, optional + The resolution - the time step at which the windows are slided. + If None, will be set to ``window_size / 20``. + Default: None Returns ------- cps : list of list - one list for each window size `h`, containing the points detected with - the corresponding `filter_process`. N.B.: only cps whose h-neighborhood - does not include previously detected cps (with smaller window h) are - added to the list. + The change points, + one list for each window size `h`, containing the points detected with + the corresponding `filter_process`. N.B.: only cps whose h-neighborhood + does not include previously detected cps (with smaller window h) are + added to the list. + """ - if (test_quantile is None) and (test_param is None): + if test_quantile is None and test_param is None: test_quantile, test_param = empirical_parameters(window_sizes, t_final, alpha, n_surrogates, time_step) @@ -116,8 +120,6 @@ def multiple_filter_test(window_sizes, spiketrain, t_final, alpha, test_param = empirical_parameters(window_sizes, t_final, alpha, n_surrogates, time_step)[1] - spk = spiketrain - # List of lists of detected change points (CPs), to be returned cps = [] @@ -125,7 +127,8 @@ def multiple_filter_test(window_sizes, spiketrain, t_final, alpha, # automatic setting of time_step dt_temp = h / 20 if time_step is None else time_step # filter_process for window of size h - t, differences = _filter_process(dt_temp, h, spk, t_final, test_param) + t, differences = _filter_process(dt_temp, h, spiketrain, t_final, + test_param) time_index = np.arange(len(differences)) # Point detected with window h cps_window = [] @@ -251,45 +254,65 @@ def _limit_processes(window_sizes, t_final, time_step): @deprecated_alias(dt='time_step') -def empirical_parameters(window_sizes, t_final, alpha, n_surrogates, +def empirical_parameters(window_sizes, t_final, alpha, n_surrogates=1000, time_step=None): - """ + r""" This function generates the threshold and the null parameters. - The`_filter_process_h` has been proved to converge (for t_fin, - h-->infinity) to a continuous functional of a Brownaian motion + The filter processes (`h`) have been proved to converge (for `t_final`, + :math:`h \to \infty`) to a continuous functional of a Brownian motion ('limit_process'). Using a MonteCarlo technique, maxima of these limit_processes are collected. The threshold is defined as the alpha quantile of this set of maxima. Namely: - test_quantile := alpha quantile of {max_(h in window_size)[ - max_(t in [h, t_final-h])_limit_process_h(t)]} + + test_quantile := alpha quantile of + :math:`{\max_{h \in \text{window\_sizes}} \max_{t \in [h, t_{final}-h]} + \text{limit\_process}_h(t)}` Parameters ---------- - window_sizes : list of quantity objects - set of windows' size - t_final : quantity object - final time of the spike + window_sizes : list of pq.Quantity + list that contains windows sizes + t_final : pq.Quantity + The final time of the spike train which is to be analysed alpha : float - alpha-quantile in range [0, 100] - n_surrogates : integer - numbers of simulated limit processes - time_step : quantity object - resolution, time step at which the windows are slided + Alpha-quantile in range [0, 100] for the set of maxima of the limit + processes + n_surrogates : int, optional + The number of simulated limit processes. + Default: 1000 + time_step : pq.Quantity or None, optional + The resolution - the time step at which the windows are slided. + If None, will be set to ``window_size / 20``. + Default: None Returns ------- test_quantile : float - threshold for the maxima of the filter derivative processes, if any + The threshold for the maxima of the filter derivative processes; if any of these maxima is larger than this value, it is assumed the - presence of a cp at the time corresponding to that maximum - - test_param : np.array 3 * num of window, + presence of a change point (cp) at the time corresponding to that + maximum. + test_param : (3, num. of windows) np.ndarray first row: list of `h`, second and third rows: empirical means and - variances of the limit process correspodning to `h`. This will be - used to normalize the `filter_process` in order to give to the every - maximum the same impact on the global statistic. + variances of the limit process corresponding to `h`. This will be + used to normalize the *filter processes* in order to give to the + every maximum the same impact on the global statistic. + + Examples + -------- + >>> import quantities as pq + >>> from elephant.change_point_detection import empirical_parameters + >>> test_quantile, test_param = empirical_parameters( + ... window_sizes=[0.5] * pq.s, t_final=2.1 * pq.s, alpha=5, + ... n_surrogates=100, time_step=0.1 * pq.s) + >>> test_quantile + 1.8133759165692873 + >>> test_param + array([[0.5 ], + [1.74482974], + [0.24290945]]) """ # try: diff --git a/elephant/conversion.py b/elephant/conversion.py index b3cbd7c0b..aed60920a 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -8,15 +8,14 @@ .. autosummary:: - :toctree: toctree/conversion + :toctree: _toctree/conversion BinnedSpikeTrain BinnedSpikeTrainView binarize - Examples --------- +******** >>> import neo >>> import quantities as pq >>> from elephant.conversion import BinnedSpikeTrain @@ -30,10 +29,20 @@ >>> bst.to_array() array([[2, 1, 0, 1, 1, 1, 1, 0, 0], [2, 1, 1, 0, 1, 1, 0, 0, 1]], dtype=int32) + +Binarizing the binned matrix. + >>> bst.to_bool_array() array([[ True, True, False, True, True, True, True, False, False], [ True, True, True, False, True, True, False, False, True]]) +>>> bst_binary = bst.binarize() +>>> bst_binary +BinnedSpikeTrainView(t_start=0.0 s, t_stop=9.0 s, bin_size=1.0 s; shape=(2, 9)) +>>> bst_binary.to_array() +array([[1, 1, 0, 1, 1, 1, 1, 0, 0], + [1, 1, 1, 0, 1, 1, 0, 0, 1]], dtype=int32) + Slicing. >>> bst.time_slice(t_stop=3.5 * pq.s) @@ -54,7 +63,14 @@ >>> BinnedSpikeTrain(bst.to_spike_trains(), bin_size=bst.bin_size) == bst True -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +Rescale the units of a binned spike train without changing the data. + +>>> bst.rescale('ms') +>>> bst +BinnedSpikeTrain(t_start=0.0 ms, t_stop=9000.0 ms, bin_size=1000.0 ms; +shape=(2, 9)) + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ @@ -69,7 +85,7 @@ import scipy.sparse as sps from elephant.utils import is_binary, deprecated_alias, is_time_quantity, \ - check_neo_consistency, get_common_start_stop_times, round_binning_errors + check_neo_consistency, round_binning_errors __all__ = [ "binarize", @@ -103,23 +119,23 @@ def binarize(spiketrain, sampling_rate=None, t_start=None, t_stop=None, The sampling rate to use for the time points. If not specified, retrieved from the `sampling_rate` attribute of `spiketrain`. - Default: None. + Default: None t_start : float or pq.Quantity, optional The start time to use for the time points. If not specified, retrieved from the `t_start` attribute of `spiketrain`. If this is not present, defaults to `0`. Any element of `spiketrain` lower than `t_start` is ignored. - Default: None. + Default: None t_stop : float or pq.Quantity, optional The stop time to use for the time points. If not specified, retrieved from the `t_stop` attribute of `spiketrain`. If this is not present, defaults to the maximum value of `spiketrain`. Any element of `spiketrain` higher than `t_stop` is ignored. - Default: None. + Default: None return_times : bool, optional If True, also return the corresponding time points. - Default: False. + Default: False Returns ------- @@ -211,12 +227,11 @@ def binarize(spiketrain, sampling_rate=None, t_start=None, t_stop=None, # figure out what to output if not return_times: return res - elif units is None: + if units is None: return res, np.arange(t_start, t_stop + sampling_period, sampling_period) - else: - return res, pq.Quantity(np.arange(t_start, t_stop + sampling_period, - sampling_period), units=units) + return res, pq.Quantity(np.arange(t_start, t_stop + sampling_period, + sampling_period), units=units) ########################################################################### @@ -298,21 +313,14 @@ class BinnedSpikeTrain(object): UserWarning If some spikes fall outside of [`t_start`, `t_stop`] range - See also - -------- - _convert_to_binned - spike_indices - to_bool_array - to_array - Notes ----- There are four minimal configurations of the optional parameters which have to be provided, otherwise a `ValueError` will be raised: - * `t_start`, `n_bins`, `bin_size` - * `t_start`, `n_bins`, `t_stop` - * `t_start`, `bin_size`, `t_stop` - * `t_stop`, `n_bins`, `bin_size` + * t_start, n_bins, bin_size + * t_start, n_bins, t_stop + * t_start, bin_size, t_stop + * t_stop, n_bins, bin_size If `spiketrains` is a `neo.SpikeTrain` or a list thereof, it is enough to explicitly provide only one parameter: `n_bins` or `bin_size`. The @@ -352,29 +360,48 @@ def __init__(self, spiketrains, bin_size=None, n_bins=None, t_start=None, @property def shape(self): + """ + The shape of the sparse matrix. + """ return self.sparse_matrix.shape @property def bin_size(self): + """ + Bin size quantity. + """ return pq.Quantity(self._bin_size, units=self.units, copy=False) @property def t_start(self): + """ + t_start quantity; spike times below this value have been ignored. + """ return pq.Quantity(self._t_start, units=self.units, copy=False) @property def t_stop(self): + """ + t_stop quantity; spike times above this value have been ignored. + """ return pq.Quantity(self._t_stop, units=self.units, copy=False) @property def binsize(self): + """ + Deprecated in favor of :attr:`bin_size`. + """ warnings.warn("'.binsize' is deprecated; use '.bin_size'", DeprecationWarning) return self._bin_size @property def num_bins(self): - warnings.warn("'.num_bins' is deprecated; use '.n_bins'") + """ + Deprecated in favor of :attr:`n_bins`. + """ + warnings.warn("'.num_bins' is deprecated; use '.n_bins'", + DeprecationWarning) return self.n_bins def __repr__(self): @@ -514,9 +541,8 @@ def check_consistency(): self._t_start = self._t_start.rescale(self.units).item() self._t_stop = self._t_stop.rescale(self.units).item() - start_shared, stop_shared = get_common_start_stop_times(spiketrains) - start_shared = start_shared.rescale(self.units).item() - stop_shared = stop_shared.rescale(self.units).item() + start_shared = max(st.t_start.item() for st in spiketrains) + stop_shared = min(st.t_stop.item() for st in spiketrains) tolerance = self.tolerance if tolerance is None: @@ -592,7 +618,8 @@ def bin_centers(self): def to_sparse_array(self): """ - Getter for sparse matrix with time points. + Getter for sparse matrix with time points. Deprecated in favor of + :attr:`sparse_matrix`. Returns ------- @@ -903,8 +930,8 @@ def spike_indices(self): that in turn contains for each spike the index into the binned matrix where this spike enters. - In contrast to `to_sparse_array().nonzero()`, this function will report - two spikes falling in the same bin as two entries. + In contrast to `self.sparse_matrix.nonzero()`, this function will + report two spikes falling in the same bin as two entries. Examples -------- @@ -934,8 +961,8 @@ def spike_indices(self): @property def is_binary(self): """ - Checks and returns `True` if given input is a binary input. - Beware, that the function does not know if the input is binary + Returns True if the sparse matrix contains binary values only. + Beware, that the function does not know if the input was binary because e.g `to_bool_array()` was used before or if the input is just sparse (i.e. only one spike per bin at maximum). @@ -1064,14 +1091,17 @@ def binarize(self, copy=True): @property def sparsity(self): """ + The sparsity of the sparse matrix computed as the no. of nonzero + elements divided by the matrix size. + Returns ------- float - Matrix sparsity defined as no. of nonzero elements divided by - the matrix size """ num_nonzero = self.sparse_matrix.data.shape[0] - return num_nonzero / np.prod(self.sparse_matrix.shape) + shape = self.sparse_matrix.shape + size = shape[0] * shape[1] + return num_nonzero / size def _create_sparse_matrix(self, spiketrains, sparse_format): """ diff --git a/elephant/cubic.py b/elephant/cubic.py index 112234eb3..9aec56164 100644 --- a/elephant/cubic.py +++ b/elephant/cubic.py @@ -1,32 +1,57 @@ # -*- coding: utf-8 -*- -''' +""" CuBIC is a statistical method for the detection of higher order of correlations in parallel spike trains based on the analysis of the cumulants of the population count. -Given a list sts of SpikeTrains, the analysis comprises the following -steps: + +.. autosummary:: + :toctree: _toctree/cubic + + cubic + +Examples +-------- +Homogeneous Poisson random spike trains population count histogram third +cumulant is explained by the first correlation order (xi=1). + +Given a list of spike trains, the analysis comprises the following steps: 1) compute the population histogram (PSTH) with the desired bin size - >>> bin_size = 5 * pq.ms - >>> pop_count = elephant.statistics.time_histogram(sts, bin_size) + +>>> import numpy as np +>>> import quantities as pq +>>> from elephant import statistics +>>> from elephant.cubic import cubic +>>> from elephant.spike_train_generation import homogeneous_poisson_process + +>>> np.random.seed(10) +>>> spiketrains = [homogeneous_poisson_process(rate=10*pq.Hz, +... t_stop=10 * pq.s) for _ in range(20)] +>>> pop_count = statistics.time_histogram(spiketrains, bin_size=0.1 * pq.s) 2) apply CuBIC to the population count - >>> alpha = 0.05 # significance level of the tests used - >>> xi, p_val, k = cubic(data, max_iterations=100, alpha=0.05, - ... errorval=4.): -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +>>> xi, p_val, kappa, test_aborted = cubic(pop_count, alpha=0.05) +>>> xi +1 +>>> p_val +[0.43014065113883904] +>>> kappa +[20.1, 22.656565656565657, 27.674706246134818] + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. -''' -# -*- coding: utf-8 -*- +""" from __future__ import division, print_function, unicode_literals -import scipy.stats -import scipy.special import math +import numpy as np import warnings +import scipy.special +import scipy.stats + from elephant.utils import deprecated_alias __all__ = [ @@ -41,8 +66,8 @@ @deprecated_alias(data='histogram', ximax='max_iterations') def cubic(histogram, max_iterations=100, alpha=0.05): r""" - Performs the CuBIC analysis [1]_ on a population histogram, calculated - from a population of spiking neurons. + Performs the CuBIC analysis :cite:`cubic-Staude2010_327` on a population + histogram, calculated from a population of spiking neurons. The null hypothesis :math:`H_0: k_3(data)<=k^*_{3,\xi}` is iteratively tested with increasing correlation order :math:`\xi` until it is possible @@ -51,7 +76,7 @@ def cubic(histogram, max_iterations=100, alpha=0.05): :math:`k_3(data)`. :math:`k^*_{3,\xi}` is the maximized third cumulant, supposing a Compound - Poisson Process (CPP) model for correlated spike trains (see [1]_) + Poisson Process (CPP) model for correlated spike trains (see the paper) with maximum order of correlation equal to :math:`\xi`. Parameters @@ -61,13 +86,13 @@ def cubic(histogram, max_iterations=100, alpha=0.05): population of neurons. max_iterations : int, optional The maximum number of iterations of the hypothesis test. Corresponds - to the :math:`\hat{\xi_{\text{max}}}` in [1]_. If it is not possible - to compute the :math:`\hat{\xi}` before `max_iterations` iteration, - the CuBIC procedure is aborted. - Default: 100. + to the :math:`\hat{\xi_{\text{max}}}` in :cite:`cubic-Staude2010_327`. + If it is not possible to compute the :math:`\hat{\xi}` before + `max_iterations` iteration, the CuBIC procedure is aborted. + Default: 100 alpha : float, optional The significance level of the hypothesis tests performed. - Default: 0.05. + Default: 0.05 Returns ------- @@ -83,20 +108,14 @@ def cubic(histogram, max_iterations=100, alpha=0.05): test_aborted : bool Whether the test was aborted because reached the maximum number of iteration, `max_iterations`. - - References - ---------- - .. [1] Staude, Rotter, Gruen, (2009) J. Comp. Neurosci - """ - # alpha in in the interval [0,1] if alpha < 0 or alpha > 1: - raise ValueError( - 'the significance level alpha (= %s) has to be in [0,1]' % alpha) + raise ValueError(f'the significance level alpha ({alpha}) has to be ' + f'in [0, 1] range') if not isinstance(max_iterations, int) or max_iterations < 0: - raise ValueError("'max_iterations' ({}) has to be a positive integer" - .format(max_iterations)) + raise ValueError(f"'max_iterations' ({max_iterations}) has to be a " + "positive integer") # dict of all possible rate functions try: @@ -117,8 +136,8 @@ def cubic(histogram, max_iterations=100, alpha=0.05): while pval < alpha: xi_hat = xi if xi > max_iterations: - warnings.warn('Test aborted, xihat= %i > ximax= %i' % ( - xi, max_iterations)) + warnings.warn(f'Test aborted after ximax={max_iterations} ' + f'iterations with p-value={pval}') test_aborted = True break @@ -131,7 +150,7 @@ def cubic(histogram, max_iterations=100, alpha=0.05): def _H03xi(kappa, xi, L): - ''' + """ Computes the p_value for testing the :math:`H_0: k_3(data)<=k^*_{3,\\xi}` hypothesis of CuBIC in the stationary rate version @@ -150,13 +169,15 @@ def _H03xi(kappa, xi, L): ----- p : float The p-value of the hypothesis tests - ''' + """ # Check the order condition of the cumulants necessary to perform CuBIC if kappa[1] < kappa[0]: - raise ValueError( - 'H_0 can not be tested:' - 'kappa(2) = %f < %f = kappa(1)!!!' % (kappa[1], kappa[0])) + raise ValueError(f"The null hypothesis H_0 cannot be tested: the " + f"population count histogram variance ({kappa[1]}) " + f"is less than the mean ({kappa[0]}). This can " + f"happen when the spike train population is not " + f"large enough or the bin size is small.") else: # computation of the maximized cumulants kstar = [_kappamstar(kappa[:2], i, xi) for i in range(2, 7)] @@ -173,7 +194,7 @@ def _H03xi(kappa, xi, L): def _kappamstar(kappa, m, xi): - ''' + """ Computes maximized cumulant of order m Parameters @@ -189,7 +210,7 @@ def _kappamstar(kappa, m, xi): ----- k_out : list The maximized cumulant of order m - ''' + """ if xi == 1: kappa_out = kappa[1] @@ -201,7 +222,7 @@ def _kappamstar(kappa, m, xi): def _kstat(data): - ''' + """ Compute first three cumulants of a population count of a population of spiking See http://mathworld.wolfram.com/k-Statistic.html @@ -216,7 +237,7 @@ def _kstat(data): ----- moments : list The first three unbiased cumulants of the population count - ''' + """ if len(data) == 0: raise ValueError('The input data must be a non-empty array') moments = [scipy.stats.kstat(data, n=n) for n in [1, 2, 3]] diff --git a/elephant/current_source_density.py b/elephant/current_source_density.py index bb5782875..edf5b2cee 100644 --- a/elephant/current_source_density.py +++ b/elephant/current_source_density.py @@ -1,38 +1,36 @@ # -*- coding: utf-8 -*- -"""'Current Source Density analysis (CSD) is a class of methods of analysis of +""" +*\"Current Source Density analysis (CSD) is a class of methods of analysis of extracellular electric potentials recorded at multiple sites leading to estimates of current sources generating the measured potentials. It is usually applied to low-frequency part of the potential (called the Local Field Potential, LFP) and to simultaneous recordings or to recordings taken with -fixed time reference to the onset of specific stimulus (Evoked Potentials)' +fixed time reference to the onset of specific stimulus (Evoked Potentials).\"* (Definition by Prof.Daniel K. Wójcik for Encyclopedia of Computational -Neuroscience) +Neuroscience.) CSD is also called as Source Localization or Source Imaging in the EEG circles. Here are CSD methods for different types of electrode configurations. -1D - laminar probe like electrodes. -2D - Microelectrode Array like -3D - UtahArray or multiple laminar probes. +- 1D - laminar probe like electrodes. +- 2D - Microelectrode Array like +- 3D - UtahArray or multiple laminar probes. The following methods have been implemented so far -1D - StandardCSD, DeltaiCSD, SplineiCSD, StepiCSD, KCSD1D -2D - KCSD2D, MoIKCSD (Saline layer on top of slice) -3D - KCSD3D +- 1D: StandardCSD, DeltaiCSD, SplineiCSD, StepiCSD, KCSD1D +- 2D: KCSD2D, MoIKCSD (Saline layer on top of slice) +- 3D: KCSD3D -Each of these methods listed have some advantages. The KCSD methods for -instance can handle broken or irregular electrode configurations electrode +Each listed method has certain advantages. The KCSD methods, for instance, can +handle broken or irregular electrode configurations electrode. -Keywords: LFP; CSD; Multielectrode; Laminar electrode; Barrel cortex +.. autosummary:: + :toctree: _toctree/current_source_density -Citation Policy: See ./current_source_density_src/README.md + estimate_csd + generate_lfp -Contributors to this current source density estimation module are: -Chaitanya Chintaluri(CC), Espen Hagen(EH) and Michał Czerwinski(MC). -EH implemented the iCSD methods and StandardCSD -CC implemented the kCSD methods, kCSD1D(MC and CC) -CC and EH developed the interface to elephant. """ from __future__ import division, print_function, unicode_literals @@ -68,7 +66,7 @@ def estimate_csd(lfp, coordinates=None, method=None, process_estimate=True, **kwargs): """ Function call to compute the current source density (CSD) from - extracellular potential recordings(local-field potentials - LFP) using + extracellular potential recordings (local field potentials - LFP) using laminar electrodes or multi-contact electrodes with 2D or 3D geometries. Parameters diff --git a/elephant/current_source_density_src/README.md b/elephant/current_source_density_src/README.md index dc3c47b39..0eeb2e84b 100644 --- a/elephant/current_source_density_src/README.md +++ b/elephant/current_source_density_src/README.md @@ -34,7 +34,8 @@ Issues 1Ð2, 30 June 2006, Pages 116-133, ISSN 0165-0270, http://dx.doi.org/10.1016/j.jneumeth.2005.12.005. (http://www.sciencedirect.com/science/article/pii/S0165027005004541) -To see an example of usage of the methods, see the file demo_icsd.py +To see an example of usage of the methods, see +[demo_icsd.py](https://github.com/espenhgn/iCSD/blob/master/demo_icsd.py) KCSD ---- diff --git a/elephant/current_source_density_src/icsd.py b/elephant/current_source_density_src/icsd.py index 5b7fc9794..ab81ced46 100644 --- a/elephant/current_source_density_src/icsd.py +++ b/elephant/current_source_density_src/icsd.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -''' +""" py-iCSD toolbox! Translation of the core functionality of the CSDplotter MATLAB package to python. @@ -31,7 +31,7 @@ - Espen.Hagen@umb.no, 2010, - e.hagen@fz-juelich.de, 2015-2016 -''' +""" import numpy as np import scipy.integrate as si @@ -40,9 +40,9 @@ class CSD(object): - '''Base iCSD class''' + """Base iCSD class""" def __init__(self, lfp, f_type='gaussian', f_order=(3, 1)): - '''Initialize parent class iCSD + """Initialize parent class iCSD Parameters ---------- @@ -52,7 +52,7 @@ def __init__(self, lfp, f_type='gaussian', f_order=(3, 1)): type of spatial filter, must be a scipy.signal filter design method f_order : list settings for spatial filter, arg passed to filter design function - ''' + """ self.name = 'CSD estimate parent class' self.lfp = lfp self.f_matrix = np.eye(lfp.shape[0]) * pq.m**3 / pq.S @@ -60,7 +60,7 @@ def __init__(self, lfp, f_type='gaussian', f_order=(3, 1)): self.f_order = f_order def get_csd(self, ): - ''' + """ Perform the CSD estimate from the LFP and forward matrix F, i.e as CSD=F**-1*LFP @@ -71,13 +71,13 @@ def get_csd(self, ): ------- csd : np.ndarray * quantity.Quantity Array with the csd estimate - ''' + """ csd = np.linalg.solve(self.f_matrix, self.lfp) return csd * (self.f_matrix.units**-1 * self.lfp.units).simplified def filter_csd(self, csd, filterfunction='convolve'): - ''' + """ Spatial filtering of the CSD estimate, using an N-point filter Arguments @@ -87,7 +87,7 @@ def filter_csd(self, csd, filterfunction='convolve'): filterfunction : str 'filtfilt' or 'convolve'. Apply spatial filter using scipy.signal.filtfilt or scipy.signal.convolve. - ''' + """ if self.f_type == 'gaussian': try: assert(len(self.f_order) == 2) @@ -145,12 +145,12 @@ def filter_csd(self, csd, filterfunction='convolve'): class StandardCSD(CSD): - ''' + """ Standard CSD method with and without Vaknin electrodes - ''' + """ def __init__(self, lfp, coord_electrode, **kwargs): - ''' + """ Initialize standard CSD method class with & without Vaknin electrodes. Parameters @@ -172,7 +172,7 @@ def __init__(self, lfp, coord_electrode, **kwargs): f_order : list settings for spatial filter, arg passed to filter design function Defaults to (3,1) for the gaussian - ''' + """ self.parameters(**kwargs) CSD.__init__(self, lfp, self.f_type, self.f_order) @@ -202,12 +202,12 @@ def __init__(self, lfp, coord_electrode, **kwargs): self.f_inv_matrix = self.get_f_inv_matrix() def parameters(self, **kwargs): - '''Defining the default values of the method passed as kwargs + """Defining the default values of the method passed as kwargs Parameters ---------- **kwargs Same as those passed to initialize the Class - ''' + """ self.sigma = kwargs.pop('sigma', 0.3 * pq.S / pq.m) self.vaknin_el = kwargs.pop('vaknin_el', True) self.f_type = kwargs.pop('f_type', 'gaussian') @@ -216,7 +216,7 @@ def parameters(self, **kwargs): raise TypeError('Invalid keyword arguments:', kwargs.keys()) def get_f_inv_matrix(self): - '''Calculate the inverse F-matrix for the standard CSD method''' + """Calculate the inverse F-matrix for the standard CSD method""" h_val = abs(np.diff(self.coord_electrode)[0]) f_inv = -np.eye(self.lfp.shape[0]) @@ -226,14 +226,14 @@ def get_f_inv_matrix(self): return f_inv * -self.sigma / h_val def get_csd(self): - ''' + """ Perform the iCSD calculation, i.e: iCSD=F_inv*LFP Returns ------- csd : np.ndarray * quantity.Quantity Array with the csd estimate - ''' + """ csd = np.dot(self.f_inv_matrix, self.lfp)[1:-1, ] # `np.dot()` does not return correct units, so the units of `csd` must # be assigned manually @@ -244,11 +244,11 @@ def get_csd(self): class DeltaiCSD(CSD): - ''' + """ delta-iCSD method - ''' + """ def __init__(self, lfp, coord_electrode, **kwargs): - ''' + """ Initialize the delta-iCSD method class object Parameters @@ -274,7 +274,7 @@ def __init__(self, lfp, coord_electrode, **kwargs): f_order : list settings for spatial filter, arg passed to filter design function Defaults to (3,1) for gaussian - ''' + """ self.parameters(**kwargs) CSD.__init__(self, lfp, self.f_type, self.f_order) @@ -313,12 +313,12 @@ def __init__(self, lfp, coord_electrode, **kwargs): self.f_matrix = self.get_f_matrix() def parameters(self, **kwargs): - '''Defining the default values of the method passed as kwargs + """Defining the default values of the method passed as kwargs Parameters ---------- **kwargs Same as those passed to initialize the Class - ''' + """ self.diam = kwargs.pop('diam', 500E-6 * pq.m) self.sigma = kwargs.pop('sigma', 0.3 * pq.S / pq.m) self.sigma_top = kwargs.pop('sigma_top', 0.3 * pq.S / pq.m) @@ -328,7 +328,7 @@ def parameters(self, **kwargs): raise TypeError('Invalid keyword arguments:', kwargs.keys()) def get_f_matrix(self): - '''Calculate the F-matrix''' + """Calculate the F-matrix""" f_matrix = np.empty((self.coord_electrode.size, self.coord_electrode.size)) * self.coord_electrode.units for j in range(self.coord_electrode.size): @@ -348,10 +348,10 @@ def get_f_matrix(self): class StepiCSD(CSD): - '''step-iCSD method''' + """step-iCSD method""" def __init__(self, lfp, coord_electrode, **kwargs): - ''' + """ Initializing step-iCSD method class object Parameters @@ -383,7 +383,7 @@ def __init__(self, lfp, coord_electrode, **kwargs): f_order : list settings for spatial filter, arg passed to filter design function Defaults to (3,1) for the gaussian - ''' + """ self.parameters(**kwargs) CSD.__init__(self, lfp, self.f_type, self.f_order) @@ -428,12 +428,12 @@ def __init__(self, lfp, coord_electrode, **kwargs): self.f_matrix = self.get_f_matrix() def parameters(self, **kwargs): - '''Defining the default values of the method passed as kwargs + """Defining the default values of the method passed as kwargs Parameters ---------- **kwargs Same as those passed to initialize the Class - ''' + """ self.diam = kwargs.pop('diam', 500E-6 * pq.m) self.h = kwargs.pop('h', np.ones(23) * 100E-6 * pq.m) @@ -446,7 +446,7 @@ def parameters(self, **kwargs): raise TypeError('Invalid keyword arguments:', kwargs.keys()) def get_f_matrix(self): - '''Calculate F-matrix for step iCSD method''' + """Calculate F-matrix for step iCSD method""" el_len = self.coord_electrode.size f_matrix = np.zeros((el_len, el_len)) for j in range(el_len): @@ -477,17 +477,17 @@ def get_f_matrix(self): return f_matrix * self.h.units**2 / self.sigma.units def _f_cylinder(self, zeta, z_val, diam, sigma): - '''function used by class method''' + """function used by class method""" f_cyl = 1. / (2. * sigma) * \ (np.sqrt((diam / 2)**2 + ((z_val - zeta))**2) - abs(z_val - zeta)) return f_cyl class SplineiCSD(CSD): - '''spline iCSD method''' + """spline iCSD method""" def __init__(self, lfp, coord_electrode, **kwargs): - ''' + """ Initializing spline-iCSD method class object Parameters @@ -519,7 +519,7 @@ def __init__(self, lfp, coord_electrode, **kwargs): num_steps : int number of data points for the spatially upsampled LFP/CSD data Defaults to 200 - ''' + """ self.parameters(**kwargs) CSD.__init__(self, lfp, self.f_type, self.f_order) @@ -552,12 +552,12 @@ def __init__(self, lfp, coord_electrode, **kwargs): self.f_matrix = self.get_f_matrix() def parameters(self, **kwargs): - '''Defining the default values of the method passed as kwargs + """Defining the default values of the method passed as kwargs Parameters ---------- **kwargs Same as those passed to initialize the Class - ''' + """ self.diam = kwargs.pop('diam', 500E-6 * pq.m) self.sigma = kwargs.pop('sigma', 0.3 * pq.S / pq.m) self.sigma_top = kwargs.pop('sigma_top', 0.3 * pq.S / pq.m) @@ -569,7 +569,7 @@ def parameters(self, **kwargs): raise TypeError('Invalid keyword arguments:', kwargs.keys()) def get_f_matrix(self): - '''Calculate the F-matrix for cubic spline iCSD method''' + """Calculate the F-matrix for cubic spline iCSD method""" el_len = self.coord_electrode.size z_js = np.zeros(el_len + 1) z_js[:-1] = np.array(self.coord_electrode) @@ -641,7 +641,7 @@ def get_f_matrix(self): return f_matrix * self.coord_electrode.units**2 / self.sigma.units def get_csd(self): - ''' + """ Calculate the iCSD using the spline iCSD method Returns @@ -650,7 +650,7 @@ def get_csd(self): Array with csd estimate - ''' + """ e_mat = self._calc_e_matrices() el_len = self.coord_electrode.size @@ -700,24 +700,24 @@ def get_csd(self): return csd * csd_unit def _f_mat0(self, zeta, z_val, sigma, diam): - '''0'th order potential function''' + """0'th order potential function""" return 1. / (2. * sigma) * \ (np.sqrt((diam / 2)**2 + ((z_val - zeta))**2) - abs(z_val - zeta)) def _f_mat1(self, zeta, z_val, zi_val, sigma, diam): - '''1'th order potential function''' + """1'th order potential function""" return (zeta - zi_val) * self._f_mat0(zeta, z_val, sigma, diam) def _f_mat2(self, zeta, z_val, zi_val, sigma, diam): - '''2'nd order potential function''' + """2'nd order potential function""" return (zeta - zi_val)**2 * self._f_mat0(zeta, z_val, sigma, diam) def _f_mat3(self, zeta, z_val, zi_val, sigma, diam): - '''3'rd order potential function''' + """3'rd order potential function""" return (zeta - zi_val)**3 * self._f_mat0(zeta, z_val, sigma, diam) def _calc_k_matrix(self): - '''Calculate the K-matrix used by to calculate E-matrices''' + """Calculate the K-matrix used by to calculate E-matrices""" el_len = self.coord_electrode.size h = float(np.diff(self.coord_electrode).min()) @@ -749,7 +749,7 @@ def _calc_k_matrix(self): np.dot(np.dot(c_j0, c_j0), tj0))) def _calc_e_matrices(self): - '''Calculate the E-matrices used by cubic spline iCSD method''' + """Calculate the E-matrices used by cubic spline iCSD method""" el_len = self.coord_electrode.size # expanding electrode grid h = float(np.diff(self.coord_electrode).min()) diff --git a/elephant/gpfa/gpfa.py b/elephant/gpfa/gpfa.py index 0d9d1142a..17a13a384 100644 --- a/elephant/gpfa/gpfa.py +++ b/elephant/gpfa/gpfa.py @@ -1,9 +1,9 @@ """ Gaussian-process factor analysis (GPFA) is a dimensionality reduction method -[#f1]_ for neural trajectory visualization of parallel spike trains. GPFA -applies factor analysis (FA) to time-binned spike count data to reduce the -dimensionality and at the same time smoothes the resulting low-dimensional -trajectories by fitting a Gaussian process (GP) model to them. +:cite:`gpfa-Yu2008_1881` for neural trajectory visualization of parallel spike +trains. GPFA applies factor analysis (FA) to time-binned spike count data to +reduce the dimensionality and at the same time smoothes the resulting +low-dimensional trajectories by fitting a Gaussian process (GP) model to them. The input consists of a set of trials (Y), each containing a list of spike trains (N neurons). The output is the projection (X) of the data in a space @@ -35,7 +35,7 @@ .. autosummary:: - :toctree: toctree/gpfa + :toctree: _toctree/gpfa GPFA @@ -58,17 +58,13 @@ ?filepath=doc/tutorials/gpfa.ipynb -References ----------- +Original code +------------- The code was ported from the MATLAB code based on Byron Yu's implementation. The original MATLAB code is available at Byron Yu's website: https://users.ece.cmu.edu/~byronyu/software.shtml -.. [#f1] Yu MB, Cunningham JP, Santhanam G, Ryu SI, Shenoy K V, Sahani M (2009) - Gaussian-process factor analysis for low-dimensional single-trial analysis - of neural population activity. J Neurophysiol 102:614-635. - -:copyright: Copyright 2015-2019 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/gpfa/gpfa_core.py b/elephant/gpfa/gpfa_core.py index b2d03ab90..5b8021986 100644 --- a/elephant/gpfa/gpfa_core.py +++ b/elephant/gpfa/gpfa_core.py @@ -2,7 +2,7 @@ """ GPFA core functionality. -:copyright: Copyright 2015-2019 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ @@ -480,7 +480,6 @@ def learn_gp_params(seqs_latent, params, verbose=False): if params['notes']['learnGPNoise']: raise ValueError("learnGPNoise is not supported.") param_name = 'gamma' - fname = 'gpfa_util.grad_betgam' param_init = params[param_name] param_opt = {param_name: np.empty_like(param_init)} @@ -492,7 +491,7 @@ def learn_gp_params(seqs_latent, params, verbose=False): for i in range(x_dim): const = {'eps': params['eps'][i]} initp = np.log(param_init[i]) - res_opt = optimize.minimize(eval(fname), initp, + res_opt = optimize.minimize(gpfa_util.grad_betgam, initp, args=(precomp[i], const), method='L-BFGS-B', jac=True) param_opt['gamma'][i] = np.exp(res_opt.x) diff --git a/elephant/gpfa/gpfa_util.py b/elephant/gpfa/gpfa_util.py index bf0d15c6e..05deccab9 100644 --- a/elephant/gpfa/gpfa_util.py +++ b/elephant/gpfa/gpfa_util.py @@ -2,7 +2,7 @@ """ GPFA util functions. -:copyright: Copyright 2015-2019 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/kernels.py b/elephant/kernels.py index 9aa523913..27fa41582 100644 --- a/elephant/kernels.py +++ b/elephant/kernels.py @@ -6,10 +6,10 @@ Symmetric kernels -~~~~~~~~~~~~~~~~~ +***************** .. autosummary:: - :toctree: toctree/kernels/ + :toctree: _toctree/kernels/ RectangularKernel TriangularKernel @@ -18,22 +18,56 @@ LaplacianKernel Asymmetric kernels -~~~~~~~~~~~~~~~~~~ +****************** .. autosummary:: - :toctree: toctree/kernels/ + :toctree: _toctree/kernels/ ExponentialKernel AlphaKernel Examples --------- ->>> import quantities as pq ->>> kernel1 = GaussianKernel(sigma=100*pq.ms) ->>> kernel2 = ExponentialKernel(sigma=8*pq.ms, invert=True) +******** + +Example 1. Gaussian kernel -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +>>> import neo +>>> import quantities as pq +>>> from elephant import kernels +>>> kernel = kernels.GaussianKernel(sigma=300 * pq.ms) +>>> kernel +GaussianKernel(sigma=300.0 ms, invert=False) +>>> spiketrain = neo.SpikeTrain([-1, 0, 1], t_start=-1, t_stop=1, units='s') +>>> kernel_pdf = kernel(spiketrain) +>>> kernel_pdf +array([0.00514093, 1.3298076 , 0.00514093]) * 1/s + +Cumulative Distribution Function + +>>> kernel.cdf(0 * pq.s) +0.5 +>>> kernel.cdf(1 * pq.s) +0.9995709396668032 + +Inverse Cumulative Distribution Function + +>>> kernel.icdf(0.5) +array(0.) * ms +>>> kernel.icdf(0.9) +array(384.46546966) * ms + +Example 2. Alpha kernel + +>>> kernel = kernels.AlphaKernel(sigma=1 * pq.s) +>>> kernel(spiketrain) +array([-0. , 0. , 0.48623347]) * 1/s +>>> kernel.cdf(0 * pq.s) +0.0 +>>> kernel.icdf(0.5) +array(1.18677054) * s + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -91,7 +125,7 @@ class Kernel(object): invert : bool, optional If True, asymmetric kernels (e.g., exponential or alpha kernels) are inverted along the time axis. - Default: False. + Default: False Raises ------ @@ -523,16 +557,13 @@ class EpanechnikovLikeKernel(SymmetricKernel): The Epanechnikov kernel under full consideration of its axioms has a half width of :math:`\sqrt{5}`. Ignoring one axiom also the respective kernel - with half width = 1 can be called Epanechnikov kernel [1]_. + with half width = 1 can be called `Epanechnikov kernel + `_. However, arbitrary width of this type of kernel is here preferred to be called 'Epanechnikov-like' kernel. The parameter `invert` has no effect on symmetric kernels. - References - ---------- - .. [1] https://de.wikipedia.org/wiki/Epanechnikov-Kern - Examples -------- @@ -586,16 +617,40 @@ def icdf(self, fraction): def boundary_enclosing_area_fraction(self, fraction): r""" - Refer to :func:`Kernel.boundary_enclosing_area_fraction` for the - documentation. + Calculates the boundary :math:`b` so that the integral from + :math:`-b` to :math:`b` encloses a certain fraction of the + integral over the complete kernel. + + By definition the returned value is hence non-negative, even if the + whole probability mass of the kernel is concentrated over negative + support for inverted kernels. + + Parameters + ---------- + fraction : float + Fraction of the whole area which has to be enclosed. + + Returns + ------- + pq.Quantity + Boundary of the kernel containing area `fraction` under the + kernel density. + + Raises + ------ + ValueError + If `fraction` was chosen too close to one, such that in + combination with integral approximation errors the calculation of + a boundary was not possible. Notes ----- For Epanechnikov-like kernels, integration of its density within the boundaries 0 and :math:`b`, and then solving for :math:`b` leads to the problem of finding the roots of a polynomial of third order. - The implemented formulas are based on the solution of this problem - given in [1]_, where the following 3 solutions are given: + The implemented formulas are based on the solution of a + `cubic function `_, + where the following 3 solutions are given: * :math:`u_1 = 1`, solution on negative side; * :math:`u_2 = \frac{-1 + i\sqrt{3}}{2}`, solution for larger @@ -605,11 +660,6 @@ def boundary_enclosing_area_fraction(self, fraction): The solution :math:`u_3` is the relevant one for the problem at hand, since it involves only positive area contributions. - - References - ---------- - .. [1] https://en.wikipedia.org/wiki/Cubic_function - """ self._check_fraction(fraction) # Python's complex-operator cannot handle quantities, hence the diff --git a/elephant/neo_tools.py b/elephant/neo_tools.py index e5f84da23..e2cd4da84 100644 --- a/elephant/neo_tools.py +++ b/elephant/neo_tools.py @@ -2,7 +2,15 @@ """ Tools to manipulate Neo objects. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +.. autosummary:: + :toctree: _toctree/neo_tools + + extract_neo_attributes + get_all_spiketrains + get_all_events + get_all_epochs + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -35,19 +43,19 @@ def extract_neo_attributes(neo_object, parents=True, child_first=True, parents : bool, optional If True, also include attributes and annotations from parent Neo objects (if any). - Default: True. + Default: True child_first : bool, optional If True, values of child attributes are used over parent attributes in the event of a name conflict. If False, parent attributes are used. This parameter does nothing if `parents` is False. - Default: True. + Default: True skip_array : bool, optional If True, skip attributes that store non-scalar array values. - Default: False. + Default: False skip_none : bool, optional If True, skip annotations and attributes that have a value of None. - Default: False. + Default: False Returns ------- diff --git a/elephant/pandas_bridge.py b/elephant/pandas_bridge.py index 8527994af..ff400d055 100644 --- a/elephant/pandas_bridge.py +++ b/elephant/pandas_bridge.py @@ -2,7 +2,18 @@ """ Bridge to the pandas library. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +.. autosummary:: + :toctree: _toctree/pandas_bridge + + spiketrain_to_dataframe + event_to_dataframe + epoch_to_dataframe + multi_spiketrains_to_dataframe + multi_events_to_dataframe + multi_epochs_to_dataframe + slice_spiketrain + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/parallel/__init__.py b/elephant/parallel/__init__.py index 2f253504b..6395eea6c 100644 --- a/elephant/parallel/__init__.py +++ b/elephant/parallel/__init__.py @@ -25,7 +25,7 @@ ------------------- .. autosummary:: - :toctree: toctree/parallel/ + :toctree: _toctree/parallel/ ProcessPoolExecutor MPIPoolExecutor diff --git a/elephant/phase_analysis.py b/elephant/phase_analysis.py index 276681900..7c797e58d 100644 --- a/elephant/phase_analysis.py +++ b/elephant/phase_analysis.py @@ -2,7 +2,15 @@ """ Methods for performing phase analysis. -:copyright: Copyright 2014-2018 by the Elephant team, see `doc/authors.rst`. +.. autosummary:: + :toctree: _toctree/phase_analysis + + spike_triggered_phase + phase_locking_value + mean_phase_vector + phase_difference + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -86,6 +94,15 @@ def spike_triggered_phase(hilbert_transform, spiketrains, interpolate): ... elephant.signal_processing.hilbert(analogsignal), ... spiketrain, ... interpolate=True) + >>> phases + [array([-0.57890515, 1.03105904, -0.82241075, ..., 0.90023903, + 2.23702263, 2.93744259])] + >>> amps + [array([0.86117412, 1.08918248, 0.98256318, ..., 1.05760518, 1.08407016, + 1.01927305]) * dimensionless] + >>> times + [array([6.41327152e+00, 2.02715221e+01, 1.05827312e+02, ..., + 9.99692942e+04, 9.99808429e+04, 9.99870120e+04]) * ms] """ diff --git a/elephant/signal_processing.py b/elephant/signal_processing.py index 570a7e9d7..e512bfd70 100644 --- a/elephant/signal_processing.py +++ b/elephant/signal_processing.py @@ -1,8 +1,19 @@ # -*- coding: utf-8 -*- """ -Basic processing procedures for analog signals (e.g., performing a z-score of a +Basic processing procedures for time series (e.g., performing a z-score of a signal, or filtering a signal). +.. autosummary:: + :toctree: _toctree/signal_processing + + zscore + cross_correlation_function + butter + wavelet_transform + hilbert + rauc + derivative + :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -81,6 +92,7 @@ def zscore(signal, inplace=True): >>> import neo >>> import numpy as np >>> import quantities as pq + >>> from elephant.signal_processing import zscore ... >>> a = neo.AnalogSignal( ... np.array([1, 2, 3, 4, 5, 6]).reshape(-1,1) * pq.mV, @@ -171,9 +183,8 @@ def zscore(signal, inplace=True): def cross_correlation_function(signal, channel_pairs, hilbert_envelope=False, n_lags=None, scaleopt='unbiased'): r""" - Computes unbiased estimator of the cross-correlation function. - - The calculations are based on [1]_: + Computes an estimator of the cross-correlation function + :cite:`signal-Stoica2005`. .. math:: @@ -204,14 +215,14 @@ def cross_correlation_function(signal, channel_pairs, hilbert_envelope=False, hilbert_envelope : bool, optional If True, returns the Hilbert envelope of cross-correlation function result. - Default: False. + Default: False n_lags : int, optional Defines the number of lags for cross-correlation function. If a `float` is passed, it will be rounded to the nearest integer. Number of samples of output is `2*n_lags+1`. If None, the number of samples of the output is equal to the number of samples of the input signal (namely `nt`). - Default: None. + Default: None scaleopt : {'none', 'biased', 'unbiased', 'normalized', 'coeff'}, optional Normalization option, equivalent to matlab `xcorr(..., scaleopt)`. Specified as one of the following. @@ -238,7 +249,7 @@ def cross_correlation_function(signal, channel_pairs, hilbert_envelope=False, R_{xy,coeff}(\tau) = \frac{1}{\sqrt{R_{xx}(0) R_{yy}(0)}} R_{xy}(\tau) - Default: 'unbiased'. + Default: 'unbiased' Returns ------- @@ -264,18 +275,12 @@ def cross_correlation_function(signal, channel_pairs, hilbert_envelope=False, If `scaleopt` is not one of the predefined above keywords. - References - ---------- - .. [1] Stoica, P., & Moses, R. (2005). Spectral Analysis of Signals. - Prentice Hall. Retrieved from http://user.it.uu.se/~ps/SAS-new.pdf, - Eq. 2.2.3. - Examples -------- >>> import neo >>> import quantities as pq >>> import matplotlib.pyplot as plt - ... + >>> from elephant.signal_processing import cross_correlation_function >>> dt = 0.02 >>> N = 2018 >>> f = 0.5 @@ -283,8 +288,9 @@ def cross_correlation_function(signal, channel_pairs, hilbert_envelope=False, >>> x = np.zeros((N,2)) >>> x[:,0] = 0.2 * np.sin(2.*np.pi*f*t) >>> x[:,1] = 5.3 * np.cos(2.*np.pi*f*t) - ... - >>> # Generate neo.AnalogSignals from x and find cross-correlation + + Generate neo.AnalogSignals from x and find cross-correlation + >>> signal = neo.AnalogSignal(x, units='mV', t_start=0.*pq.ms, >>> sampling_rate=1/dt*pq.Hz, dtype=float) >>> rho = cross_correlation_function(signal, [0,1], n_lags=150) @@ -382,7 +388,7 @@ def butter(signal, highpass_frequency=None, lowpass_frequency=None, order=4, highpass_frequency : pq.Quantity of float, optional High-pass cut-off frequency. If `float`, the given value is taken as frequency in Hz. - Default: None. + Default: None lowpass_frequency : pq.Quantity or float, optional Low-pass cut-off frequency. If `float`, the given value is taken as frequency in Hz. @@ -399,10 +405,10 @@ def butter(signal, highpass_frequency=None, lowpass_frequency=None, order=4, * `highpass_frequency` > `lowpass_frequency`: bandstop filter - Default: None. + Default: None order : int, optional Order of the Butterworth filter. - Default: 4. + Default: 4 filter_function : {'filtfilt', 'lfilter', 'sosfiltfilt'}, optional Filtering function to be used. Available filters: @@ -415,17 +421,17 @@ def butter(signal, highpass_frequency=None, lowpass_frequency=None, order=4, In most applications 'filtfilt' should be used, because it doesn't bring about phase shift due to filtering. For numerically stable filtering, in particular higher order filters, use 'sosfiltfilt' - (see [1]_). - Default: 'filtfilt'. + (see https://github.com/NeuralEnsemble/elephant/issues/220). + Default: 'filtfilt' sampling_frequency : pq.Quantity or float, optional The sampling frequency of the input time series. When given as `float`, its value is taken as frequency in Hz. When `signal` is given as `neo.AnalogSignal`, its attribute is used to specify the sampling frequency and this parameter is ignored. - Default: 1.0. + Default: 1.0 axis : int, optional Axis along which filter is applied. - Default: last axis (-1). + Default: last axis (-1) Returns ------- @@ -441,9 +447,29 @@ def butter(signal, highpass_frequency=None, lowpass_frequency=None, order=4, If both `highpass_frequency` and `lowpass_frequency` are None. - References - ---------- - .. [1] https://github.com/NeuralEnsemble/elephant/issues/220 + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.signal_processing import butter + >>> noise = neo.AnalogSignal(np.random.normal(size=5000), + ... sampling_rate=1000 * pq.Hz, units='mV') + >>> filtered_noise = butter(noise, highpass_frequency=250.0 * pq.Hz) + >>> filtered_noise + AnalogSignal with 1 channels of length 5000; units mV; datatype float64 + sampling rate: 1000.0 Hz + time: 0.0 s to 5.0 s + + Let's check that the normal noise power spectrum at zero frequency is close + to zero. + + >>> from elephant.spectral import welch_psd + >>> freq, psd = welch_psd(filtered_noise, fs=1000.0) + >>> psd.shape + (1, 556) + >>> freq[0], psd[0, 0] + (array(0.) * Hz, array(7.21464674e-08) * mV**2/Hz) """ available_filters = 'lfilter', 'filtfilt', 'sosfiltfilt' @@ -521,9 +547,8 @@ def wavelet_transform(signal, frequency, n_cycles=6.0, sampling_frequency=1.0, zero_padding=True): r""" Compute the wavelet transform of a given signal with Morlet mother - wavelet. - - The parametrization of the wavelet is based on [1]_. + wavelet. The parametrization of the wavelet is based on + :cite:`signal-Le2001_83`. Parameters ---------- @@ -538,25 +563,25 @@ def wavelet_transform(signal, frequency, n_cycles=6.0, sampling_frequency=1.0, computes the wavelet transforms for all the given frequencies at once. n_cycles : float, optional Size of the mother wavelet (approximate number of oscillation cycles - within a wavelet). Corresponds to :math:`nco` in the paper [1]_. - A larger `n_cycles` value leads to a higher frequency resolution and a - lower temporal resolution, and vice versa. + within a wavelet). Corresponds to :math:`nco` in + :cite:`signal-Le2001_83`. A larger `n_cycles` value leads to a higher + frequency resolution and a lower temporal resolution, and vice versa. Typically used values are in a range of 3–8, but one should be cautious when using a value smaller than ~ 6, in which case the admissibility of - the wavelet is not ensured (cf. [2]_). - Default: 6.0. + the wavelet is not ensured :cite:`signal-Farge1992_395`. + Default: 6.0 sampling_frequency : float, optional Sampling rate of the input data in Hz. When `signal` is given as a `neo.AnalogSignal`, the sampling frequency is taken from its attribute and this parameter is ignored. - Default: 1.0. + Default: 1.0 zero_padding : bool, optional Specifies whether the data length is extended to the least power of 2 greater than the original length, by padding zeros to the tail, for speeding up the computation. If True, the extended part is cut out from the final result before returned, so that the output has the same length as the input. - Default: True. + Default: True Returns ------- @@ -590,16 +615,29 @@ def wavelet_transform(signal, frequency, n_cycles=6.0, sampling_frequency=1.0, Notes ----- `n_cycles` is related to the wavelet number :math:`w` as - :math:`w \sim 2 \pi \frac{n_{\text{cycles}}}{6}`, as defined in [1]_. + :math:`w \sim 2 \pi \frac{n_{\text{cycles}}}{6}` as defined in + :cite:`signal-Le2001_83`. - References - ---------- - .. [1] M. Le Van Quyen, J. Foucher, J. Lachaux, E. Rodriguez, A. Lutz, - J. Martinerie, & F.J. Varela, "Comparison of Hilbert transform and - wavelet methods for the analysis of neuronal synchrony," J Neurosci - Meth, vol. 111, pp. 83–98, 2001. - .. [2] M. Farge, "Wavelet Transforms and their Applications to - Turbulence," Annu Rev Fluid Mech, vol. 24, pp. 395–458, 1992. + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.signal_processing import wavelet_transform + >>> noise = neo.AnalogSignal(np.random.normal(size=7), + ... sampling_rate=11 * pq.Hz, units='mV') + + The wavelet frequency must be less than the half of the sampling rate; + picking at 5 Hz. + + >>> wavelet_transform(noise, frequency=5) + array([[-1.00890049+3.003473j ], + [-1.43664254-2.8389273j ], + [ 3.02499511+0.96534578j], + [-2.79543976+1.4581079j ], + [ 0.94387304-2.98159518j], + [ 1.41476471+2.77389985j], + [-2.95996766-0.9872236j ]]) """ def _morlet_wavelet_ft(freq, n_cycles, fs, n): @@ -704,7 +742,7 @@ def hilbert(signal, padding='nextpow'): If 'nextpow', zero-pad to the next length that is a power of 2. If it is an `int`, directly specify the length to zero-pad to (indicates the number of Fourier components). - Default: 'nextpow'. + Default: 'nextpow' Returns ------- @@ -723,11 +761,11 @@ def hilbert(signal, padding='nextpow'): Create a sine signal at 5 Hz with increasing amplitude and calculate the instantaneous phases: + >>> import neo >>> import numpy as np >>> import quantities as pq - >>> import neo >>> import matplotlib.pyplot as plt - ... + >>> from elephant.signal_processing import hilbert >>> t = np.arange(0, 5000) * pq.ms >>> f = 5. * pq.Hz >>> a = neo.AnalogSignal( @@ -811,7 +849,7 @@ def rauc(signal, baseline=None, bin_duration=None, t_start=None, t_stop=None): channel-by-channel basis. If 'median', the median value of the entire `signal` is subtracted on a channel-by-channel basis. - Default: None. + Default: None bin_duration : pq.Quantity, optional The length of time that each integration should span. If None, there will be only one bin spanning the entire signal @@ -819,11 +857,11 @@ def rauc(signal, baseline=None, bin_duration=None, t_start=None, t_stop=None): If `bin_duration` does not divide evenly into the signal duration, the end of the signal is padded with zeros to accomodate the final, overextending bin. - Default: None. - t_start: pq.Quantity, optional + Default: None + t_start : pq.Quantity, optional Time to start the algorithm. If None, starts at the beginning of `signal`. - Default: None. + Default: None t_stop : pq.Quantity, optional Time to end the algorithm. If None, ends at the last time of `signal`. @@ -832,7 +870,7 @@ def rauc(signal, baseline=None, bin_duration=None, t_start=None, t_stop=None): the signal but want the mean or median calculation (`baseline`='mean' or `baseline`='median') to use the entire signal for better baseline estimation. - Default: None. + Default: None Returns ------- @@ -857,6 +895,17 @@ def rauc(signal, baseline=None, bin_duration=None, t_start=None, t_stop=None): -------- neo.AnalogSignal.time_slice : how `t_start` and `t_stop` are used + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.signal_processing import rauc + >>> signal = neo.AnalogSignal(np.arange(10), sampling_rate=20 * pq.Hz, + ... units='mV') + >>> rauc(signal) + array(2.025) * mV/Hz + """ if not isinstance(signal, neo.AnalogSignal): @@ -932,7 +981,7 @@ def derivative(signal): Returns ------- - derivative_sig: neo.AnalogSignal + derivative_sig : neo.AnalogSignal The returned object is a `neo.AnalogSignal` containing the differences between each successive sample value of the input signal divided by the sampling period. Times are centered between the successive samples @@ -944,6 +993,19 @@ def derivative(signal): TypeError If `signal` is not a `neo.AnalogSignal`. + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.signal_processing import derivative + >>> signal = neo.AnalogSignal([0, 3, 4, 11, -1], sampling_rate=1 * pq.Hz, + ... units='mV') + >>> print(derivative(signal)) + [[ 3.] + [ 1.] + [ 7.] + [-12.]] mV*Hz """ if not isinstance(signal, neo.AnalogSignal): diff --git a/elephant/spade.py b/elephant/spade.py index 68454a9d4..a639a1976 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -1,11 +1,12 @@ """ -SPADE [1]_, [2]_, [3]_ is the combination of a mining technique and multiple -statistical tests to detect and assess the statistical significance of repeated -occurrences of spike sequences (spatio-temporal patterns, STP). +SPADE :cite:`spade-Torre2013_132,spade-Quaglio2017_41,spade-Stella2019_104022` +is the combination of a mining technique and multiple statistical tests to +detect and assess the statistical significance of repeated occurrences of spike +sequences (spatio-temporal patterns, STP). .. autosummary:: - :toctree: toctree/spade + :toctree: _toctree/spade spade concepts_mining @@ -32,61 +33,56 @@ implementation of the fast fca algorithm contained in `elephant/spade_src/fast_fca.py`, which is about 10 times slower. +See Also +-------- +elephant.cell_assembly_detection.cell_assembly_detection : another synchronous +patterns detection + + Examples -------- Given a list of Neo Spiketrain objects, assumed to be recorded in parallel, the SPADE analysis can be applied as demonstrated in this short toy example of 10 artificial spike trains of exhibiting fully synchronous events of order 10. ->>> from elephant.spade import spade ->>> import elephant.spike_train_generation >>> import quantities as pq +>>> import numpy as np +>>> from elephant.spike_train_generation import compound_poisson_process +>>> from elephant.spade import spade Generate correlated spiketrains. ->>> spiketrains = elephant.spike_train_generation.cpp( -... rate=5*pq.Hz, A=[0]+[0.99]+[0]*9+[0.01], t_stop=10*pq.s) +>>> np.random.seed(30) +>>> spiketrains = compound_poisson_process(rate=15*pq.Hz, +... amplitude_distribution=[0, 0.95, 0, 0, 0, 0, 0.05], t_stop=5*pq.s) Mining patterns with SPADE using a `bin_size` of 1 ms and a window length of 1 bin (i.e., detecting only synchronous patterns). ->>> patterns = spade( -... spiketrains=spiketrains, bin_size=1*pq.ms, winlen=1, dither=5*pq.ms, -... min_spikes=10, n_surr=10, psr_param=[0,0,3], -... output_format='patterns')['patterns'][0] - ->>> import matplotlib.pyplot as plt ->>> for neu in patterns['neurons']: -... label = 'pattern' if neu == 0 else None -... plt.plot(patterns['times'], [neu]*len(patterns['times']), 'ro', -... label=label) - -Raster plot of the spiketrains. - ->>> for st_idx, spiketrain in enumerate(spiketrains): -... label = 'pattern' if st_idx == 0 else None -... plt.plot(spiketrain.rescale(pq.ms), [st_idx] * len(spiketrain), -... 'k.', label=label) ->>> plt.ylim([-1, len(spiketrains)]) ->>> plt.xlabel('time (ms)') ->>> plt.ylabel('neurons ids') ->>> plt.legend() ->>> plt.show() - -References ----------- -.. [1] Torre, E., Picado-Muino, D., Denker, M., Borgelt, C., & Gruen, S. - (2013). Statistical evaluation of synchronous spike patterns extracted - by frequent item set mining. Frontiers in Computational Neuroscience, 7. -.. [2] Quaglio, P., Yegenoglu, A., Torre, E., Endres, D. M., & Gruen, S. - (2017). Detection and Evaluation of Spatio-Temporal Spike Patterns in - Massively Parallel Spike Train Data with SPADE. Frontiers in - Computational Neuroscience, 11. -.. [3] Stella, A., Quaglio, P., Torre, E., & Gruen, S. (2019). 3d-SPADE: - Significance evaluation of spatio-temporal patterns of various temporal - extents. Biosystems, 185, 104022. - -:copyright: Copyright 2017 by the Elephant team, see `doc/authors.rst`. +>>> patterns = spade(spiketrains, bin_size=10 * pq.ms, winlen=1, +... dither=5 * pq.ms, min_spikes=6, n_surr=10, +... psr_param=[0, 0, 3])['patterns'] +>>> patterns[0] +{'itemset': (4, 3, 0, 2, 5, 1), + 'windows_ids': (9, + 16, + 55, + 91, + ..., + 393, + 456, + 467), + 'neurons': [4, 3, 0, 2, 5, 1], + 'lags': array([0., 0., 0., 0., 0.]) * ms, + 'times': array([ 90., 160., 550., 910., 930., 1420., 1480., 1650., 2570., + 3130., 3430., 3480., 3610., 3800., 3830., 3930., 4560., 4670.]) * ms, + 'signature': (6, 18), + 'pvalue': 0.0} + + +Refer to Viziphant documentation to check how to visualzie such patterns. + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals @@ -142,9 +138,10 @@ def spade(spiketrains, bin_size, winlen, min_spikes=2, min_occ=2, alpha=None, stat_corr='fdr_bh', surr_method='dither_spikes', psr_param=None, output_format='patterns', **surr_kwargs): r""" - Perform the SPADE [1]_, [2]_, [3]_ analysis for the parallel input - `spiketrains`. They are discretized with a temporal resolution equal to - `bin_size` in a sliding window of `winlen*bin_size`. + Perform the SPADE :cite:`spade-Torre2013_132`, + :cite:`spade-Quaglio2017_41`, :cite:`spade-Stella2019_104022` analysis for + the parallel input `spiketrains`. They are discretized with a temporal + resolution equal to `bin_size` in a sliding window of `winlen*bin_size`. First, spike patterns are mined from the `spiketrains` using a technique called frequent itemset mining (FIM) or formal concept analysis (FCA). In @@ -294,19 +291,6 @@ def spade(spiketrains, bin_size, winlen, min_spikes=2, min_occ=2, ----- If detected, this function will use MPI to parallelize the analysis. - References - ---------- - .. [1] Torre, E., Picado-Muino, D., Denker, M., Borgelt, C., & Gruen, S. - (2013). Statistical evaluation of synchronous spike patterns extracted - by frequent item set mining. Frontiers in Computational Neuroscience, 7. - .. [2] Quaglio, P., Yegenoglu, A., Torre, E., Endres, D. M., & Gruen, S. - (2017). Detection and Evaluation of Spatio-Temporal Spike Patterns in - Massively Parallel Spike Train Data with SPADE. Frontiers in - Computational Neuroscience, 11. - .. [3] Stella, A., Quaglio, P., Torre, E., & Gruen, S. (2019). 3d-SPADE: - Significance evaluation of spatio-temporal patterns of various temporal - extents. Biosystems, 185, 104022. - Examples -------- The following example applies SPADE to `spiketrains` (list of @@ -1767,10 +1751,10 @@ def approximate_stability(concepts, rel_matrix, n_subsets=0, Default: 0 delta : float, optional delta: probability with at least :math:`1-\delta` - Default: 0. + Default: 0.0 epsilon : float, optional epsilon: absolute error - Default: 0. + Default: 0.0 Returns ------- @@ -1854,21 +1838,21 @@ def _calculate_single_stability_parameter(intent, extent, Parameters ---------- - extent: np.array + extent : np.array 2nd element of concept - intent: np.array + intent : np.array 1st element of concept - n_subsets: int + n_subsets : int See approximate_stabilty - rel_matrix: sparse.coo_matrix + rel_matrix : sparse.coo_matrix See approximate_stabilty - look_at: {'extent', 'intent'} + look_at : {'extent', 'intent'} whether to determine stability for extent or intent. Default: 'intent' Returns ------- - stability: float + stability : float Stability parameter for given extent, intent depending on which to look """ if look_at == 'intent': @@ -1914,9 +1898,9 @@ def _select_random_subsets(element_1, n_subsets): Parameters ---------- - element_1: np.array + element_1 : np.array intent or extent - n_subsets: int + n_subsets : int see approximate_stability Returns @@ -2265,17 +2249,17 @@ def concept_output_to_patterns(concepts, winlen, bin_size, pv_spec=None, Parameters ---------- - concepts: tuple + concepts : tuple Each element of the tuple corresponds to a pattern which it turn is a tuple of (spikes in the pattern, occurrences of the patterns) - winlen: int + winlen : int Length (in bins) of the sliding window used for the analysis. - bin_size: pq.Quantity + bin_size : pq.Quantity The time precision used to discretize the `spiketrains` (binning). - pv_spec: None or tuple + pv_spec : None or tuple Contains a tuple of signatures and the corresponding p-value. If equal to None all p-values are set to -1. - spectrum: {'#', '3d#'} + spectrum : {'#', '3d#'} '#': pattern spectrum using the as signature the pair: (number of spikes, number of occurrences) '3d#': pattern spectrum using the as signature the triplets: @@ -2283,7 +2267,7 @@ def concept_output_to_patterns(concepts, winlen, bin_size, pv_spec=None, and first spike of the pattern) Default: '#' - t_start: pq.Quantity + t_start : pq.Quantity t_start of the analyzed spike trains Returns diff --git a/elephant/spectral.py b/elephant/spectral.py index 795ed7eec..cd41ea471 100644 --- a/elephant/spectral.py +++ b/elephant/spectral.py @@ -3,7 +3,13 @@ Identification of spectral properties in analog signals (e.g., the power spectrum). -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +.. autosummary:: + :toctree: _toctree/spectral + + welch_psd + welch_coherence + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -62,54 +68,54 @@ def welch_psd(signal, n_segments=8, len_segment=None, overlapping segments cover the entire stretch of the given data. This parameter is ignored if `len_segment` or `frequency_resolution` is given. - Default: 8. + Default: 8 len_segment : int, optional Length of segments. This parameter is ignored if `frequency_resolution` is given. If None, it will be determined from other parameters. - Default: None. + Default: None frequency_resolution : pq.Quantity or float, optional Desired frequency resolution of the obtained PSD estimate in terms of the interval between adjacent frequency bins. When given as a `float`, it is taken as frequency in Hz. If None, it will be determined from other parameters. - Default: None. + Default: None overlap : float, optional Overlap between segments represented as a float number between 0 (no overlap) and 1 (complete overlap). - Default: 0.5 (half-overlapped). + Default: 0.5 (half-overlapped) fs : pq.Quantity or float, optional Specifies the sampling frequency of the input time series. When the input is given as a `neo.AnalogSignal`, the sampling frequency is taken from its attribute and this parameter is ignored. - Default: 1.0. + Default: 1.0 window : str or tuple or np.ndarray, optional Desired window to use. See Notes [2]. - Default: 'hanning'. + Default: 'hanning' nfft : int, optional Length of the FFT used. See Notes [2]. - Default: None. + Default: None detrend : str or function or False, optional Specifies how to detrend each segment. See Notes [2]. - Default: 'constant'. + Default: 'constant' return_onesided : bool, optional If True, return a one-sided spectrum for real data. If False return a two-sided spectrum. See Notes [2]. - Default: True. + Default: True scaling : {'density', 'spectrum'}, optional If 'density', computes the power spectral density where Pxx has units of V**2/Hz. If 'spectrum', computes the power spectrum where Pxx has units of V**2, if `signal` is measured in V and `fs` is measured in Hz. See Notes [2]. - Default: 'density'. + Default: 'density' axis : int, optional Axis along which the periodogram is computed. See Notes [2]. - Default: last axis (-1). + Default: last axis (-1) Returns ------- @@ -167,6 +173,28 @@ def welch_psd(signal, n_segments=8, len_segment=None, scipy.signal.welch welch_cohere + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.spectral import welch_psd + >>> signal = neo.AnalogSignal(np.cos(np.linspace(0, 2 * np.pi, num=100)), + ... sampling_rate=20 * pq.Hz, units='mV') + + Sampling frequency will be taken as `signal.sampling_rate`. + + >>> freq, psd = welch_psd(signal) + >>> freq + array([ 0. , 0.90909091, 1.81818182, 2.72727273, + 3.63636364, 4.54545455, 5.45454545, 6.36363636, + 7.27272727, 8.18181818, 9.09090909, 10. ]) * Hz + >>> psd + array([[1.09566410e-03, 2.33607943e-02, 1.35436832e-03, + 6.74408723e-05, 1.00810196e-05, 2.40079315e-06, + 7.35821437e-07, 2.58361700e-07, 9.44183422e-08, + 3.14573483e-08, 6.82050475e-09, 1.18183354e-10]]) * mV**2/Hz + """ # initialize a parameter dict (to be given to scipy.signal.welch()) with @@ -277,49 +305,49 @@ def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, Number of segments. The length of segments is adjusted so that overlapping segments cover the entire stretch of the given data. This parameter is ignored if `len_seg` or `frequency_resolution` is given. - Default: 8. + Default: 8 len_segment : int, optional Length of segments. This parameter is ignored if `frequency_resolution` is given. If None, it is determined from other parameters. - Default: None. + Default: None frequency_resolution : pq.Quantity or float, optional Desired frequency resolution of the obtained coherence estimate in terms of the interval between adjacent frequency bins. When given as a `float`, it is taken as frequency in Hz. If None, it is determined from other parameters. - Default: None. + Default: None overlap : float, optional Overlap between segments represented as a float number between 0 (no overlap) and 1 (complete overlap). - Default: 0.5 (half-overlapped). + Default: 0.5 (half-overlapped) fs : pq.Quantity or float, optional Specifies the sampling frequency of the input time series. When the input time series are given as `neo.AnalogSignal`, the sampling frequency is taken from their attribute and this parameter is ignored. - Default: 1.0. + Default: 1.0 window : str or tuple or np.ndarray, optional Desired window to use. See Notes [1]. - Default: 'hanning'. + Default: 'hanning' nfft : int, optional Length of the FFT used. See Notes [1]. - Default: None. + Default: None detrend : str or function or False, optional Specifies how to detrend each segment. See Notes [1]. - Default: 'constant'. + Default: 'constant' scaling : {'density', 'spectrum'}, optional If 'density', computes the power spectral density where Pxx has units of V**2/Hz. If 'spectrum', computes the power spectrum where Pxx has units of V**2, if `signal` is measured in V and `fs` is measured in Hz. See Notes [1]. - Default: 'density'. + Default: 'density' axis : int, optional Axis along which the periodogram is computed. See Notes [1]. - Default: last axis (-1). + Default: last axis (-1) Returns ------- @@ -373,6 +401,27 @@ def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, -------- welch_psd + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.spectral import welch_coherence + >>> signal = neo.AnalogSignal(np.cos(np.linspace(0, 2 * np.pi, num=100)), + ... sampling_rate=20 * pq.Hz, units='mV') + + Sampling frequency will be taken as `signal.sampling_rate`. + + >>> freq, coherency, phase_lag = welch_coherence(signal, signal) + >>> freq + array([ 0. , 0.90909091, 1.81818182, 2.72727273, + 3.63636364, 4.54545455, 5.45454545, 6.36363636, + 7.27272727, 8.18181818, 9.09090909, 10. ]) * Hz + >>> coherency.flatten() + array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]) + >>> phase_lag.flatten() + array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) * rad + """ # TODO: code duplication with welch_psd() @@ -458,3 +507,4 @@ def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, def welch_cohere(*args, **kwargs): warnings.warn("'welch_cohere' is deprecated; use 'welch_coherence'", DeprecationWarning) + return welch_coherence(*args, **kwargs) diff --git a/elephant/spike_train_correlation.py b/elephant/spike_train_correlation.py index 6a1986b09..3f5d21736 100644 --- a/elephant/spike_train_correlation.py +++ b/elephant/spike_train_correlation.py @@ -3,7 +3,7 @@ This modules provides functions to calculate correlations between spike trains. .. autosummary:: - :toctree: toctree/spike_train_correlation + :toctree: _toctree/spike_train_correlation covariance correlation_coefficient @@ -11,7 +11,7 @@ spike_time_tiling_coefficient spike_train_timescale -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals @@ -24,6 +24,7 @@ import scipy.signal from scipy import integrate +from elephant.conversion import BinnedSpikeTrain from elephant.utils import deprecated_alias __all__ = [ @@ -148,8 +149,8 @@ def correlate_memory(self, cch_mode): right_edge + i, side='right') timediff = st2_bin_idx_unique[il:ir] - i assert ((timediff >= left_edge) & ( - timediff <= right_edge)).all(), 'Not all the ' - 'entries of cch lie in the window' + timediff <= right_edge)).all(), \ + 'Not all the entries of cch lie in the window' cross_corr[timediff - left_edge] += ( st1_spmat[idx] * st2_spmat[il:ir]) st2_bin_idx_unique = st2_bin_idx_unique[il:] @@ -308,12 +309,12 @@ def covariance(binned_spiketrain, binary=False, fast=True): If True, the spikes of a particular spike train falling in the same bin are counted as 1, resulting in binary binned vectors :math:`b_i`. If False, the binned vectors :math:`b_i` contain the spike counts per bin. - Default: False. + Default: False fast : bool, optional If `fast=True` and the sparsity of `binned_spiketrain` is `> 0.1`, use `np.cov()`. Otherwise, use memory efficient implementation. See Notes [2]. - Default: True. + Default: True Returns ------- @@ -345,19 +346,22 @@ def covariance(binned_spiketrain, binary=False, fast=True): Examples -------- - Generate two Poisson spike trains + Covariance matrix of two Poisson spike train processes. >>> import neo - >>> from quantities import s, Hz, ms + >>> import numpy as np + >>> import quantities as pq >>> from elephant.spike_train_generation import homogeneous_poisson_process >>> from elephant.conversion import BinnedSpikeTrain - >>> st1 = homogeneous_poisson_process( - ... rate=10.0*Hz, t_start=0.0*s, t_stop=10.0*s) - >>> st2 = homogeneous_poisson_process( - ... rate=10.0*Hz, t_start=0.0*s, t_stop=10.0*s) - >>> cov_matrix = covariance(BinnedSpikeTrain([st1, st2], bin_size=5*ms)) - >>> print(cov_matrix[0, 1]) - -0.001668334167083546 + >>> from elephant.spike_train_correlation import covariance + + >>> np.random.seed(1) + >>> st1 = homogeneous_poisson_process(rate=10*pq.Hz, t_stop=10.0*pq.s) + >>> st2 = homogeneous_poisson_process(rate=10*pq.Hz, t_stop=10.0*pq.s) + >>> cov_matrix = covariance(BinnedSpikeTrain([st1, st2], bin_size=5*pq.ms)) + >>> cov_matrix + array([[ 0.05432316, -0.00152276], + [-0.00152276, 0.04917234]]) """ if binary: @@ -410,12 +414,12 @@ def correlation_coefficient(binned_spiketrain, binary=False, fast=True): If True, two spikes of a particular spike train falling in the same bin are counted as 1, resulting in binary binned vectors :math:`b_i`. If False, the binned vectors :math:`b_i` contain the spike counts per bin. - Default: False. + Default: False fast : bool, optional If `fast=True` and the sparsity of `binned_spiketrain` is `> 0.1`, use `np.corrcoef()`. Otherwise, use memory efficient implementation. See Notes[2] - Default: True. + Default: True Returns ------- @@ -448,21 +452,23 @@ def correlation_coefficient(binned_spiketrain, binary=False, fast=True): Examples -------- - Generate two Poisson spike trains + Correlation coefficient of two Poisson spike train processes. >>> import neo - >>> from quantities import s, Hz, ms + >>> import numpy as np + >>> import quantities as pq >>> from elephant.spike_train_generation import homogeneous_poisson_process >>> from elephant.conversion import BinnedSpikeTrain - >>> st1 = homogeneous_poisson_process( - ... rate=10.0*Hz, t_start=0.0*s, t_stop=10.0*s) - >>> st2 = homogeneous_poisson_process( - ... rate=10.0*Hz, t_start=0.0*s, t_stop=10.0*s) - >>> cc_matrix = correlation_coefficient(BinnedSpikeTrain([st1, st2], - ... bin_size=5*ms)) - >>> print(cc_matrix[0, 1]) - 0.015477320222075359 - + >>> from elephant.spike_train_correlation import correlation_coefficient + + >>> np.random.seed(1) + >>> st1 = homogeneous_poisson_process(rate=10*pq.Hz, t_stop=10.0*pq.s) + >>> st2 = homogeneous_poisson_process(rate=10*pq.Hz, t_stop=10.0*pq.s) + >>> corrcoef = correlation_coefficient(BinnedSpikeTrain([st1, st2], + ... bin_size=5*pq.ms)) + >>> corrcoef + array([[ 1. , -0.02946313], + [-0.02946313, 1. ]]) """ if binary: binned_spiketrain = binned_spiketrain.binarize() @@ -554,12 +560,11 @@ def cross_correlation_histogram( Visualization of this function is covered in Viziphant: :func:`viziphant.spike_train_correlation.plot_cross_correlation_histogram`. - Parameters ---------- - binned_spiketrain_i, binned_spiketrain_j : - elephant.conversion.BinnedSpikeTrain - Binned spike trains of lengths N and M to cross-correlate. The input + binned_spiketrain_i, binned_spiketrain_j : BinnedSpikeTrain + Binned spike trains of lengths N and M to cross-correlate - the output + of :class:`elephant.conversion.BinnedSpikeTrain`. The input spike trains can have any `t_start` and `t_stop`. window : {'valid', 'full'} or list of int, optional ‘full’: This returns the cross-correlation at each point of overlap, @@ -574,7 +579,7 @@ def cross_correlation_histogram( The entries of window are two integers representing the left and right extremes (expressed as number of bins) where the cross-correlation is computed. - Default: 'full'. + Default: 'full' border_correction : bool, optional whether to correct for the border effect. If True, the value of the CCH at bin :math:`b` (for :math:`b=-H,-H+1, ...,H`, where :math:`H` is @@ -584,11 +589,11 @@ def cross_correlation_histogram( (H+1)/(H+1-|b|), which linearly corrects for loss of bins at the edges. - Default: False. + Default: False binary : bool, optional If True, spikes falling in the same bin are counted as a single spike; otherwise they are counted as different spikes. - Default: False. + Default: False kernel : np.ndarray or None, optional A one dimensional array containing a smoothing kernel applied to the resulting CCH. The length N of the kernel indicates the @@ -600,7 +605,7 @@ def cross_correlation_histogram( * hanning: `numpy.hanning(N)` * bartlett: `numpy.bartlett(N)` If None, the CCH is not smoothed. - Default: None. + Default: None method : {'speed', 'memory'}, optional Defines the algorithm to use. "speed" uses `numpy.correlate` to calculate the correlation between two binned spike trains using a @@ -608,12 +613,12 @@ def cross_correlation_histogram( fastest realization. In contrast, the option "memory" uses an own implementation to calculate the correlation based on sparse matrices, which is more memory efficient but slower than the "speed" option. - Default: "speed". + Default: "speed" cross_correlation_coefficient : bool, optional If True, a normalization is applied to the CCH to obtain the cross-correlation coefficient function ranging from -1 to 1 according - to Equation (5.10) in [1]_. See Notes. - Default: False. + to Equation (5.10) in :cite:`correlation-Eggermont2010_77`. See Notes. + Default: False Returns ------- @@ -647,45 +652,44 @@ def cross_correlation_histogram( Notes ----- - 1. The Eq. (5.10) in [1]_ is valid for binned spike trains with at most one - spike per bin. For a general case, refer to the implementation of - `_covariance_sparse()`. + 1. The Eq. (5.10) in :cite:`correlation-Eggermont2010_77` is valid for + binned spike trains with at most one spike per bin. For a general case, + refer to the implementation of `_covariance_sparse()`. 2. Alias: `cch` - References - ---------- - .. [1] "Analysis of parallel spike trains", 2010, Gruen & Rotter, Vol 7. - Examples -------- Plot the cross-correlation histogram between two Poisson spike trains >>> import elephant - >>> import matplotlib.pyplot as plt >>> import quantities as pq + >>> import numpy as np + >>> from elephant.conversion import BinnedSpikeTrain + >>> from elephant.spike_train_generation import homogeneous_poisson_process + >>> from elephant.spike_train_correlation import \ + ... cross_correlation_histogram - >>> binned_spiketrain_i = elephant.conversion.BinnedSpikeTrain( - ... elephant.spike_train_generation.homogeneous_poisson_process( + >>> np.random.seed(1) + >>> binned_spiketrain_i = BinnedSpikeTrain( + ... homogeneous_poisson_process( ... 10. * pq.Hz, t_start=0 * pq.ms, t_stop=5000 * pq.ms), ... bin_size=5. * pq.ms) - >>> binned_spiketrain_j = elephant.conversion.BinnedSpikeTrain( - ... elephant.spike_train_generation.homogeneous_poisson_process( + >>> binned_spiketrain_j = BinnedSpikeTrain( + ... homogeneous_poisson_process( ... 10. * pq.Hz, t_start=0 * pq.ms, t_stop=5000 * pq.ms), ... bin_size=5. * pq.ms) - >>> cc_hist = \ - ... elephant.spike_train_correlation.cross_correlation_histogram( - ... binned_spiketrain_i, binned_spiketrain_j, window=[-30,30], + >>> cc_hist, lags = cross_correlation_histogram( + ... binned_spiketrain_i, binned_spiketrain_j, window=[-10, 10], ... border_correction=False, - ... binary=False, kernel=None, method='memory') - - >>> plt.bar(left=cc_hist[0].times.magnitude, - ... height=cc_hist[0][:, 0].magnitude, - ... width=cc_hist[0].sampling_period.magnitude) - >>> plt.xlabel('time (' + str(cc_hist[0].times.units) + ')') - >>> plt.ylabel('cross-correlation histogram') - >>> plt.axis('tight') - >>> plt.show() + ... binary=False, kernel=None) + >>> print(cc_hist.flatten()) + [ 5. 3. 3. 2. 4. 0. 1. 5. 3. 4. 2. 2. 2. 5. + 1. 2. 4. 2. -0. 3. 3.] dimensionless + >>> lags + array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10], dtype=int32) """ @@ -812,8 +816,8 @@ def cross_correlation_histogram( @deprecated_alias(spiketrain_1='spiketrain_i', spiketrain_2='spiketrain_j') def spike_time_tiling_coefficient(spiketrain_i, spiketrain_j, dt=0.005 * pq.s): """ - Calculates the Spike Time Tiling Coefficient (STTC) as described in [1]_ - following their implementation in C. + Calculates the Spike Time Tiling Coefficient (STTC) as described in + :cite:`correlation-Cutts2014_14288` following their implementation in C. The STTC is a pairwise measure of correlation between spike trains. It has been proposed as a replacement for the correlation index as it presents several advantages (e.g. it's not confounded by firing rate, @@ -837,16 +841,16 @@ def spike_time_tiling_coefficient(spiketrain_i, spiketrain_j, dt=0.005 * pq.s): `[-dt, +dt]` of a spike of the other train. This is a Python implementation compatible with the elephant library of - the original code by C. Cutts written in C and avaiable at: - (https://github.com/CCutts/Detecting_pairwise_correlations_in_spike_trains/ - blob/master/spike_time_tiling_coefficient.c) + the original code by C. Cutts written in C and available `here + `_: Parameters ---------- - spiketrain_i, spiketrain_j: neo.SpikeTrain + spiketrain_i, spiketrain_j : neo.SpikeTrain Spike trains to cross-correlate. They must have the same `t_start` and `t_stop`. - dt: pq.Quantity. + dt : pq.Quantity. The synchronicity window is used for both: the quantification of the proportion of total recording time that lies `[-dt, +dt]` of each spike in each train and the proportion of spikes in `spiketrain_i` that lies @@ -855,20 +859,28 @@ def spike_time_tiling_coefficient(spiketrain_i, spiketrain_j, dt=0.005 * pq.s): Returns ------- - index: float or np.nan + index : float or np.nan The spike time tiling coefficient (STTC). Returns np.nan if any spike train is empty. - References - ---------- - .. [1] Cutts, C. S., & Eglen, S. J. (2014). Detecting Pairwise Correlations - in Spike Trains: An Objective Comparison of Methods and Application - to the Study of Retinal Waves. Journal of Neuroscience, 34(43), - 14288–14303. - Notes ----- Alias: `sttc` + + Examples + -------- + >>> import neo + >>> import quantities as pq + >>> from elephant.spike_train_correlation import \ + ... spike_time_tiling_coefficient + + >>> spiketrain1 = neo.SpikeTrain([1.3, 7.56, 15.87, 28.23, 30.9, 34.2, + ... 38.2, 43.2], units='ms', t_stop=50) + >>> spiketrain2 = neo.SpikeTrain([1.02, 2.71, 18.82, 28.46, 28.79, 43.6], + ... units='ms', t_stop=50) + >>> spike_time_tiling_coefficient(spiketrain1, spiketrain2) + 0.4958601655933762 + """ def run_P(spiketrain_i, spiketrain_j): @@ -974,9 +986,9 @@ def run_T(spiketrain): @deprecated_alias(binned_st='binned_spiketrain', tau_max='max_tau') def spike_train_timescale(binned_spiketrain, max_tau): r""" - Calculates the auto-correlation time of a binned spike train. - Uses the definition of the auto-correlation time proposed in [[1]_, - Eq. (6)]: + Calculates the auto-correlation time of a binned spike train; uses the + definition of the auto-correlation time proposed in + :cite:`correlation-Wieland2015_040901` (Eq. 6): .. math:: \tau_\mathrm{corr} = \int_{-\tau_\mathrm{max}}^{\tau_\mathrm{max}}\ @@ -1013,11 +1025,18 @@ def spike_train_timescale(binned_spiketrain, max_tau): defines the discretization of the integral :math:`d\tau`. If it is too big, the numerical approximation of the integral is inaccurate. - References - ---------- - .. [1] Wieland, S., Bernardi, D., Schwalger, T., & Lindner, B. (2015). - Slow fluctuations in recurrent networks of spiking neurons. - Physical Review E, 92(4), 040901. + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant.spike_train_correlation import spike_train_timescale + >>> from elephant.conversion import BinnedSpikeTrain + >>> spiketrain = neo.SpikeTrain([1, 5, 7, 8], units='ms', t_stop=10*pq.ms) + >>> bst = BinnedSpikeTrain(spiketrain, bin_size=1 * pq.ms) + >>> spike_train_timescale(bst, max_tau=5 * pq.ms) + array(14.11111111) * ms + """ if binned_spiketrain.get_num_of_spikes() < 2: warnings.warn("Spike train contains less than 2 spikes! " diff --git a/elephant/spike_train_dissimilarity.py b/elephant/spike_train_dissimilarity.py index 0e3feb639..9fcd4e458 100644 --- a/elephant/spike_train_dissimilarity.py +++ b/elephant/spike_train_dissimilarity.py @@ -11,12 +11,12 @@ .. autosummary:: - :toctree: toctree/spike_train_dissimilarity + :toctree: _toctree/spike_train_dissimilarity victor_purpura_distance van_rossum_distance -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -78,14 +78,14 @@ def victor_purpura_distance(spiketrains, cost_factor=1.0 * pq.Hz, kernel=None, ---------- spiketrains : list of neo.SpikeTrain Spike trains to calculate pairwise distance. - cost_factor: pq.Quantity + cost_factor : pq.Quantity, optional A cost factor :math:`q` for spike shifts as inverse time scalar. Extreme values :math:`q=0` meaning no cost for any shift of spikes, or :math: `q=np.inf` meaning infinite cost for any spike shift and hence exclusion of spike shifts, are explicitly allowed. If `kernel` is not `None`, :math:`q` will be ignored. Default: 1.0 * pq.Hz - kernel: kernels.Kernel + kernel : elephant.kernels.Kernel or None, optional Kernel to use in the calculation of the distance. If `kernel` is `None`, an unnormalized triangular kernel with standard deviation of :math:'2.0/(q * sqrt(6.0))' corresponding to a half width of @@ -94,12 +94,12 @@ def victor_purpura_distance(spiketrains, cost_factor=1.0 * pq.Hz, kernel=None, the suitable width. The choice of another kernel is enabled, but this leaves the framework of Victor-Purpura distances. Default: None - sort: bool + sort : bool, optional Spike trains with sorted spike times will be needed for the calculation. You can set `sort` to `False` if you know that your spike trains are already sorted to decrease calculation time. Default: True - algorithm: string + algorithm : str, optional Allowed values are 'fast' or 'intuitive', each selecting an algorithm with which to calculate the pairwise Victor-Purpura distance. Typically 'fast' should be used, because while giving always the @@ -138,12 +138,11 @@ def victor_purpura_distance(spiketrains, cost_factor=1.0 * pq.Hz, kernel=None, if cost_factor == 0.0: num_spikes = np.atleast_2d([st.size for st in spiketrains]) return np.absolute(num_spikes.T - num_spikes) - elif cost_factor == np.inf: + if cost_factor == np.inf: num_spikes = np.atleast_2d([st.size for st in spiketrains]) return num_spikes.T + num_spikes - else: - kernel = kernels.TriangularKernel( - sigma=2.0 / (np.sqrt(6.0) * cost_factor)) + kernel = kernels.TriangularKernel( + sigma=2.0 / (np.sqrt(6.0) * cost_factor)) if sort: spiketrains = [np.sort(st.view(type=pq.Quantity)) @@ -152,16 +151,13 @@ def victor_purpura_distance(spiketrains, cost_factor=1.0 * pq.Hz, kernel=None, def compute(i, j): if i == j: return 0.0 - else: - if algorithm == 'fast': - return _victor_purpura_dist_for_st_pair_fast( - spiketrains[i], spiketrains[j], kernel) - elif algorithm == 'intuitive': - return _victor_purpura_dist_for_st_pair_intuitive( - spiketrains[i], spiketrains[j], cost_factor) - else: - raise NameError("algorithm must be either 'fast' " - "or 'intuitive'.") + if algorithm == 'fast': + return _victor_purpura_dist_for_st_pair_fast( + spiketrains[i], spiketrains[j], kernel) + if algorithm == 'intuitive': + return _victor_purpura_dist_for_st_pair_intuitive( + spiketrains[i], spiketrains[j], cost_factor) + raise NameError("The algorithm must be either 'fast' or 'intuitive'.") return _create_matrix_from_indexed_function( (len(spiketrains), len(spiketrains)), compute, kernel.is_symmetric()) @@ -311,14 +307,14 @@ def _victor_purpura_dist_for_st_pair_intuitive(spiketrain_a, spiketrain_b, @deprecated_alias(trains='spiketrains', tau='time_constant') def van_rossum_distance(spiketrains, time_constant=1.0 * pq.s, sort=True): """ - Calculates the van Rossum distance. + Calculates the van Rossum distance :cite:`dissimilarity-Rossum2001_751`, + defined as Euclidean distance of the spike trains convolved with a + causal decaying exponential smoothing filter. - It is defined as Euclidean distance of the spike trains convolved with a - causal decaying exponential smoothing filter. A detailed description can - be found in [1]_. This implementation is normalized to yield - a distance of 1.0 for the distance between an empty spike train and a - spike train with a single spike. Divide the result by sqrt(2.0) to get - the normalization used in the cited paper. + The implementation is normalized to yield a distance of 1.0 for the + distance between an empty spike train and a spike train with a single + spike. Divide the result by sqrt(2.0) to get the normalization used in the + paper. Given :math:`N` spike trains with :math:`n` spikes on average the run-time complexity of this function is :math:`O(N^2 n)`. @@ -330,9 +326,9 @@ def van_rossum_distance(spiketrains, time_constant=1.0 * pq.s, sort=True): time_constant : Quantity scalar Decay rate of the exponential function as time scalar. Controls for which time scale the metric will be sensitive. Denoted as :math:`t_c` - in [1]_. This parameter will be ignored if `kernel` is not `None`. - May also be :const:`scipy.inf` which will lead to only measuring - differences in spike count. + in :cite:`dissimilarity-Rossum2001_751`. This parameter will be + ignored if `kernel` is not `None`. May also be :const:`scipy.inf` + which will lead to only measuring differences in spike count. Default: 1.0 * pq.s sort : bool Spike trains with sorted spike times might be needed for the @@ -346,11 +342,6 @@ def van_rossum_distance(spiketrains, time_constant=1.0 * pq.s, sort=True): 2-D Matrix containing the van Rossum distances for all pairs of spike trains. - References - ---------- - [1] Rossum, M. V. (2001). A novel spike distance. Neural computation, - 13(4), 751-763. - Examples -------- >>> from elephant.spike_train_dissimilarity import van_rossum_distance @@ -373,7 +364,7 @@ def van_rossum_distance(spiketrains, time_constant=1.0 * pq.s, sort=True): if time_constant == 0: spike_counts = [st.size for st in spiketrains] return np.sqrt(spike_counts + np.atleast_2d(spike_counts).T) - elif time_constant == np.inf: + if time_constant == np.inf: spike_counts = [st.size for st in spiketrains] return np.absolute(spike_counts - np.atleast_2d(spike_counts).T) diff --git a/elephant/spike_train_generation.py b/elephant/spike_train_generation.py index ba9b1bac3..17433cc4f 100644 --- a/elephant/spike_train_generation.py +++ b/elephant/spike_train_generation.py @@ -1,12 +1,51 @@ # -*- coding: utf-8 -*- """ -Functions to generate spike trains from analog signals, -or to generate random spike trains. +Functions to generate/extract spike trains from analog signals, or to generate +random spike trains. + +Extract spike times from time series +*************************************** +.. autosummary:: + :toctree: _toctree/spike_train_generation + + spike_extraction + threshold_detection + peak_detection + + +Random spike train processes +**************************** +.. autosummary:: + :toctree: _toctree/spike_train_generation + + homogeneous_poisson_process + inhomogeneous_poisson_process + homogeneous_gamma_process + inhomogeneous_gamma_process + + +Coincident spike times generation +********************************* +.. autosummary:: + :toctree: _toctree/spike_train_generation + + single_interaction_process + compound_poisson_process Some functions are based on the NeuroTools stgen module, which was mostly written by Eilif Muller, or from the NeuroTools signals.analogs module. -:copyright: Copyright 2015 by the Elephant team, see `doc/authors.rst`. + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: gen + :keyprefix: generation- + :style: unsrt + + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -29,6 +68,7 @@ "homogeneous_poisson_process", "inhomogeneous_poisson_process", "homogeneous_gamma_process", + "inhomogeneous_gamma_process", "single_interaction_process", "compound_poisson_process" ] @@ -48,21 +88,21 @@ def spike_extraction(signal, threshold=0.0 * pq.mV, sign='above', An analog input signal. threshold : pq.Quantity, optional Contains a value that must be reached for an event to be detected. - Default: 0.0 * pq.mV. + Default: 0.0 * pq.mV sign : {'above', 'below'}, optional Determines whether to count threshold crossings that cross above or below the threshold. - Default: 'above'. + Default: 'above' time_stamps : pq.Quantity, optional If `spike_train` is a `pq.Quantity` array, `time_stamps` provides the time stamps around which the waveform is extracted. If it is None, the function `peak_detection` is used to calculate the time_stamps from signal. - Default: None. + Default: None interval : tuple of pq.Quantity Specifies the time interval around the `time_stamps` where the waveform is extracted. - Default: (-2 * pq.ms, 4 * pq.ms). + Default: (-2 * pq.ms, 4 * pq.ms) Returns ------- @@ -142,7 +182,6 @@ def threshold_detection(signal, threshold=0.0 * pq.mV, sign='above'): """ Returns the times when the analog signal crosses a threshold. Usually used for extracting spike times from a membrane potential. - Adapted from version in NeuroTools. Parameters ---------- @@ -150,11 +189,11 @@ def threshold_detection(signal, threshold=0.0 * pq.mV, sign='above'): An analog input signal. threshold : pq.Quantity, optional Contains a value that must be reached for an event to be detected. - Default: 0.0 * pq.mV. + Default: 0.0 * pq.mV sign : {'above', 'below'}, optional Determines whether to count threshold crossings that cross above or below the threshold. - Default: 'above'. + Default: 'above' Returns ------- @@ -210,22 +249,22 @@ def peak_detection(signal, threshold=0.0 * pq.mV, sign='above', An analog input signal. threshold : pq.Quantity, optional Contains a value that must be reached for an event to be detected. - Default: 0.*pq.mV. + Default: 0.*pq.mV sign : {'above', 'below'}, optional Determines whether to count threshold crossings that cross above or below the threshold. - Default: 'above'. + Default: 'above' as_array : bool, optional If True, a NumPy array of the resulting peak times is returned instead of a (default) `neo.SpikeTrain` object. - Default: False. + Default: False format : {None, 'raw'}, optional .. deprecated:: 0.8.0 Whether to return as SpikeTrain (None) or as a plain array of times ('raw'). Deprecated. Use `as_array=False` for None format and `as_array=True` otherwise. - Default: None. + Default: None Returns ------- @@ -351,18 +390,18 @@ def homogeneous_poisson_process(rate, t_start=0.0 * pq.ms, The rate of the discharge. t_start : pq.Quantity, optional The beginning of the spike train. - Default: 0 * pq.ms. + Default: 0 * pq.ms t_stop : pq.Quantity, optional The end of the spike train. - Default: 1000 * pq.ms. + Default: 1000 * pq.ms as_array : bool, optional If True, a NumPy array of sorted spikes is returned, rather than a `neo.SpikeTrain` object. - Default: False. + Default: False refractory_period : pq.Quantity or None, optional `pq.Quantity` scalar with dimension time. The time period after one spike no other spike is emitted. - Default: None. + Default: None Returns ------- @@ -450,11 +489,11 @@ def inhomogeneous_poisson_process(rate, as_array=False, as_array : bool, optional If True, a NumPy array of sorted spikes is returned, rather than a SpikeTrain object. - Default: False. + Default: False refractory_period : pq.Quantity or None, optional `pq.Quantity` scalar with dimension time. The time period after one spike no other spike is emitted. - Default: None. + Default: None Returns ------- @@ -620,14 +659,14 @@ def homogeneous_gamma_process(a, b, t_start=0.0 * pq.ms, t_stop=1000.0 * pq.ms, The rate parameter of the gamma distribution. t_start : pq.Quantity, optional The beginning of the spike train. - Default: 0 * pq.ms. + Default: 0 * pq.ms t_stop : pq.Quantity, optional The end of the spike train. - Default: 1000 * pq.ms. + Default: 1000 * pq.ms as_array : bool, optional If True, a NumPy array of sorted spikes is returned, rather than a `neo.SpikeTrain` object. - Default: False. + Default: False Returns ------- @@ -666,9 +705,8 @@ def homogeneous_gamma_process(a, b, t_start=0.0 * pq.ms, t_stop=1000.0 * pq.ms, def inhomogeneous_gamma_process(rate, shape_factor, as_array=False): """ Returns a spike train whose spikes are a realization of an inhomogeneous - Gamma process with the given rate profile and the given shape factor. - The implementation using operational time is inspired by Nawrot et al. - (2018) [1]_. + Gamma process with the given rate profile and the given shape factor + :cite:`generation-Nawrot2008_374`. Parameters ---------- @@ -681,7 +719,7 @@ def inhomogeneous_gamma_process(rate, shape_factor, as_array=False): as_array : bool, optional If True, a NumPy array of sorted spikes is returned, rather than a SpikeTrain object. - Default: False. + Default: False Returns ------- @@ -695,12 +733,6 @@ def inhomogeneous_gamma_process(rate, shape_factor, as_array=False): If `rate` is not a neo AnalogSignal If `rate` contains a negative value. - References - ---------- - .. [1] Nawrot, M., Boucsein, C., Denker, M., Rodriguez Molina, V., - Riehle A., Aertsen A., & Rotter, S. (2008). Measurement of - variability dynamics in cortical spike trains. Journal of - Neuroscience Methods, 169, 374–390. """ if not isinstance(rate, neo.AnalogSignal): @@ -764,7 +796,7 @@ def _n_poisson(rate, t_stop, t_start=0.0 * pq.ms, n_spiketrains=1): t_start : pq.Quantity, optional Single common start time of each output SpikeTrain. Must be < t_stop. Default: 0 * pq.ms - n_spiketrains: int, optional + n_spiketrains : int, optional If rate is a single pq.Quantity value, n specifies the number of SpikeTrains to be generated. If rate is an array, n is ignored and the number of SpikeTrains is equal to len(rate). @@ -820,14 +852,12 @@ def single_interaction_process( return_coincidences=False): """ Generates a multidimensional Poisson SIP (single interaction process) - plus independent Poisson processes + plus independent Poisson processes :cite:`generation-Kuhn2003_67`. A Poisson SIP consists of Poisson time series which are independent except for simultaneous events in all of them. This routine generates a SIP plus additional parallel independent Poisson processes. - See _[1]. - Parameters ---------- t_stop : pq.Quantity @@ -880,17 +910,13 @@ def single_interaction_process( Returns ------- - output: list - Realization of a SIP consisting of n Poisson processes characterized - by synchronous events (with the given jitter) + output : list + Realization of a SIP consisting of `n_spiketrains` Poisson processes + characterized by synchronous events (with the given jitter). If `return_coinc` is `True`, the coincidence times are returned as a second output argument. They also have an associated time unit (same as `t_stop`). - References - ---------- - .. [1] Kuhn, Aertsen, Rotter (2003) Neural Comput 15(1):67-101 - Examples -------- >>> import quantities as pq @@ -1063,9 +1089,9 @@ def _pool_spiketrains(spiketrains, extremes='inner'): Parameters ---------- - spiketrains: list of neo.SpikeTrain + spiketrains : list of neo.SpikeTrain A list of spiketrains to merge. - extremes: str, optional + extremes : str, optional Only spikes of a and b in the specified extremes are considered. * 'inner': pool all spikes from min(a.t_start b.t_start) to max(a.t_stop, b.t_stop) @@ -1281,8 +1307,9 @@ def _cpp_het_stat(A, t_stop, rates, t_start=0. * pq.ms): def compound_poisson_process( rate, amplitude_distribution, t_stop, shift=None, t_start=0 * pq.ms): """ - Generate a Compound Poisson Process (CPP; see _[1]) with a given - `amplitude_distribution` :math:`A` and stationary marginal rates `rate`. + Generate a Compound Poisson Process (CPP; see + :cite:`generation-Staude2010_327`) with a given `amplitude_distribution` + :math:`A` and stationary marginal rates `rate`. The CPP process is a model for parallel, correlated processes with Poisson spiking statistics at pre-defined firing rates. It is composed of @@ -1303,7 +1330,7 @@ def compound_poisson_process( rate : pq.Quantity Average rate of each spike train generated. Can be: - a single value, all spike trains will have same rate rate - - an array of values (of length len(A)-1), each indicating the + - an array of values (of length `len(A)-1`), each indicating the firing rate of one process in output amplitude_distribution : np.ndarray or list CPP's amplitude distribution :math:`A`. `A[j]` represents the @@ -1324,12 +1351,8 @@ def compound_poisson_process( Returns ------- list of neo.SpikeTrain - SpikeTrains with specified firing rates forming the CPP with amplitude - distribution :math:`A`. - - References - ---------- - .. [1] Staude, Rotter, Gruen (2010) J Comput Neurosci 29:327-350. + A list of `len(A) - 1` neo.SpikeTrains with specified firing rates + forming the CPP with amplitude distribution :math:`A`. """ if not isinstance(amplitude_distribution, np.ndarray): amplitude_distribution = np.array(amplitude_distribution) diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index 4e9df31ac..22f0884ce 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -1,54 +1,34 @@ # -*- coding: utf-8 -*- """ Module to generate surrogates of a spike train by randomising its spike times -in different ways (see [2]_ and [3]_). Different methods destroy different -features of the original data: - -* randomise_spikes: - randomly reposition all spikes inside the time interval (t_start, t_stop). - Keeps spike count, generates Poisson spike trains with time-stationary - firing rate -* dither_spikes: - dither each spike time around original position by a random amount; - keeps spike count and firing rates computed on a slow temporal scale; - destroys ISIs, making them more exponentially distributed -* dither_spike_train: - dither the whole input spike train (i.e. all spikes equally) by a random - amount; keeps spike count, ISIs, and firing rates computed on a slow - temporal scale -* jitter_spikes: - discretize the full time interval (t_start, t_stop) into time segments - and locally randomise the spike times (see randomise_spikes) inside each - segment. Keeps spike count inside each segment and creates locally Poisson - spike trains with locally time-stationary rates -* shuffle_isis: - shuffle the inter-spike intervals (ISIs) of the spike train randomly, - keeping the first spike time fixed and generating the others from the - new sequence of ISIs. Keeps spike count and ISIs, flattens the firing rate - profile -* joint_isi_dithering: - calculate the Joint-ISI distribution and moves spike according to the - probability distribution, that results from a fixed sum of ISI_before - and the ISI_afterwards. For further details see [1]_ and [2]_. -* bin_shuffling: - shuffles the bins of a binned spiketrain inside of exclusive windows. -* trial_shifting: - shifts each trial, i.e., each element of a list of spiketrains by a - uniformly drawn random amount. - -References ----------- -.. [1] Gerstein, G. L. (2004). Searching for significance in spatio-temporal - firing patterns. Acta Neurobiol. Exp., 64:203–207. -.. [2] Louis, S., Gerstein, G. L., Gruen, S., and Diesmann, M. (2010). - Surrogate spike train generation through dithering in operational time. - Front. Comput. Neurosci., 4(127). -.. [3] Louis, S., Borgelt, C., and Gruen, S. (2010). Generation and selection - of surrogate methods for correlation analysis. In Rotter, S. and Gruen, S., - editors, Analysis of Parallel Spike Trains. Springer, Berlin. - -Original implementation by: Emiliano Torre [e.torre@fz-juelich.de] -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +in different ways (see :cite:`surrogates-Gerstein2004_203`, +:cite:`surrogates-Louis2010_127`, and :cite:`surrogates-Louis2010_359`). +Different methods destroy different features of the original data. + + +Main function +------------- +.. autosummary:: + :toctree: _toctree/spike_train_surrogates + + surrogates + + +Surrogate types +--------------- +.. autosummary:: + :toctree: _toctree/spike_train_surrogates + + JointISI + dither_spikes + randomise_spikes + shuffle_isis + dither_spike_train + jitter_spikes + bin_shuffling + trial_shifting + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -156,18 +136,18 @@ def dither_spikes(spiketrain, dither, n_surrogates=1, decimals=None, `(t-dither, t+dither)`. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 decimals : int or None, optional Number of decimal points for every spike time in the surrogates at a millisecond level. If None, machine precision is used. - Default: None. + Default: None edges : bool, optional For surrogate spikes falling outside the range `[spiketrain.t_start, spiketrain.t_stop)`, whether to drop them out (for `edges = True`) or set them to the range's closest end (for `edges = False`). - Default: True. + Default: True refractory_period : pq.Quantity or None, optional The dither range of each spike is adjusted such that the spike can not fall into the `refractory_period` of the previous or next spike. @@ -177,7 +157,7 @@ def dither_spikes(spiketrain, dither, n_surrogates=1, decimals=None, Note, that with this option a spike cannot "jump" over the previous or next spike as it is normally possible. If set to None, no refractoriness is in dithering. - Default: None. + Default: None Returns ------- @@ -273,11 +253,11 @@ def randomise_spikes(spiketrain, n_surrogates=1, decimals=None): The spike train from which to generate the surrogates. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 decimals : int or None, optional Number of decimal points for every spike time in the surrogates. If None, machine precision is used. - Default: None. + Default: None Returns ------- @@ -338,11 +318,11 @@ def shuffle_isis(spiketrain, n_surrogates=1, decimals=None): The spike train from which to generate the surrogates. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 decimals : int or None, optional Number of decimal points for every spike time in the surrogates. If None, machine precision is used. - Default: None. + Default: None Returns ------- @@ -420,16 +400,16 @@ def dither_spike_train(spiketrain, shift, n_surrogates=1, decimals=None, drawn from the range `(-shift, +shift)`. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 decimals : int or None, optional Number of decimal points for every spike time in the surrogates. If None, machine precision is used. - Default: None. + Default: None edges : bool, optional For surrogate spikes falling outside the range `[spiketrain.t_start, spiketrain.t_stop)`, whether to drop them out (for `edges = True`) or set them to the range's closest end (for `edges = False`). - Default: True. + Default: True Returns ------- @@ -514,7 +494,7 @@ def jitter_spikes(spiketrain, bin_size, n_surrogates=1): width different from `bin_size`. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 Returns ------- @@ -605,11 +585,11 @@ def bin_shuffling( is passed to the method n_surrogates : int, optional Number of surrogates to create. - Default: 1. + Default: 1 sliding : bool, optional If True, the window is slided bin by bin (only implemented for binned spike trains). - Default: False. + Default: False Returns ------- @@ -746,11 +726,10 @@ def _continuous_time_bin_shuffling(spiketrain, max_displacement, bin_size, class JointISI(object): r""" - The class :class:`JointISI` is implemented for Joint-ISI dithering - as a continuation of the ideas of [1]_ and [2]_. + Joint-ISI dithering implementation, based on the ideas from + :cite:`surrogates-Gerstein2004_203` and :cite:`surrogates-Louis2010_127`. - When creating a class instance, all necessary preprocessing steps are done - to use :func:`JointISI.dithering` method. + The main function is :func:`JointISI.dithering`. Parameters ---------- @@ -761,61 +740,53 @@ class JointISI(object): `method` is 'window'. It is also used for the uniform dithering for the spikes, which are outside the regime in the Joint-ISI histogram, where Joint-ISI dithering is applicable. - Default: 15. * pq.ms. + Default: 15. * pq.ms truncation_limit : pq.Quantity, optional The Joint-ISI distribution of :math:`(ISI_i, ISI_{i+1})` is defined within the range :math:`[0, \infty)`. Since this is computationally not feasible, the Joint-ISI distribution is truncated for high ISI. The Joint-ISI histogram is calculated for :math:`(ISI_i, ISI_{i+1})` from 0 to `truncation_limit`. - Default: 100. * pq.ms. + Default: 100. * pq.ms n_bins : int, optional The size of the joint-ISI-distribution will be `n_bins*n_bins/2`. - Default: 100. + Default: 100 sigma : pq.Quantity, optional The standard deviation of the Gaussian kernel, with which the data is convolved. - Default: 2. * pq.ms. + Default: 2. * pq.ms alternate : bool, optional If True, then all even spikes are dithered followed by all odd spikes. Otherwise, the spikes are dithered in ascending order from the first to the last spike. - Default: True. + Default: True use_sqrt : bool, optional If True, the joint-ISI histogram is preprocessed by - applying a square root (following [1]). - Default: False. + applying a square root (following :cite:`surrogates-Gerstein2004_203`). + Default: False method : {'fast', 'window'}, optional * 'fast': the spike can move in the whole range between the previous and subsequent spikes (computationally efficient). * 'window': the spike movement is limited to the parameter `dither`. - Default: 'window'. + Default: 'window' cutoff : bool, optional If True, then the filtering of the Joint-ISI histogram is limited on the lower side by the minimal ISI. This can be necessary, if in the data there is a certain refractory period, which will be destroyed by the convolution with the 2d-Gaussian function. - Default: True. + Default: True refractory_period : pq.Quantity, optional Defines the refractory period of the dithered `spiketrain` unless the smallest ISI of the `spiketrain` is lower than this value. - Default: 4. * pq.ms. + Default: 4. * pq.ms isi_dithering : bool, optional If True, the Joint-ISI distribution is evaluated as the outer product of the ISI-distribution with itself. Thus, all serial correlations are destroyed. - Default: False. - - References - ---------- - .. [1] Gerstein, G. L. (2004). Searching for significance in - spatio-temporal firing patterns. Acta Neurobiol. Exp., 64:203–207. - .. [2] Louis, S., Gerstein, G. L., Gruen, S., and Diesmann, M. (2010). - Surrogate spike train generation through dithering in operational time. - Front. Comput. Neurosci., 4(127). + Default: False """ # The min number of spikes, required for dithering. @@ -1054,7 +1025,7 @@ def dithering(self, n_surrogates=1): ---------- n_surrogates : int The number of dithered spiketrains to be returned. - Default: 1. + Default: 1 Returns ---------- @@ -1232,7 +1203,7 @@ def trial_shifting(spiketrains, dither, n_surrogates=1): Amount of dithering. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 Returns ------- @@ -1316,7 +1287,7 @@ def _trial_shifting_of_concatenated_spiketrain( Buffering in between trials in the concatenation of the spiketrain. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 Returns ------- @@ -1354,9 +1325,8 @@ def _trial_shifting_of_concatenated_spiketrain( @deprecated_alias(n='n_surrogates', surr_method='method') -def surrogates( - spiketrain, n_surrogates=1, method='dither_spike_train', - dt=None, **kwargs): +def surrogates(spiketrain, n_surrogates=1, method='dither_spike_train', + dt=None, **kwargs): """ Generates surrogates of a `spiketrain` by a desired generation method. @@ -1376,7 +1346,7 @@ def surrogates( spike train to generate the surrogates from is 'trial_shifting'. n_surrogates : int, optional Number of surrogates to be generated. - Default: 1. + Default: 1 method : str, optional The method to use to generate surrogate spike trains. Can be one of: @@ -1403,7 +1373,7 @@ def surrogates( (`dither_spikes`, `dither_spike_train`) or replacing them randomly within a certain window (`jitter_spikes`), dt represents the size of that shift / window. For other methods, dt is ignored. - Default: None. + Default: None kwargs Keyword arguments passed to the chosen surrogate method. @@ -1435,6 +1405,10 @@ def surrogates( raise TypeError('spiketrain must be an instance neo.SpikeTrain or' ' a list of neo.SpikeTrain') + if method == "dither_spikes_with_refractory_period": + warnings.warn("'dither_spikes_with_refractory_period' is deprecated " + "in favor of 'dither_spikes'", DeprecationWarning) + # Define the surrogate function to use, depending on the specified method surrogate_types = { 'dither_spike_train': dither_spike_train, diff --git a/elephant/spike_train_synchrony.py b/elephant/spike_train_synchrony.py index 8953e4b8a..c4f0ed505 100644 --- a/elephant/spike_train_synchrony.py +++ b/elephant/spike_train_synchrony.py @@ -7,13 +7,13 @@ ------------------ .. autosummary:: - :toctree: toctree/spike_train_synchrony/ + :toctree: _toctree/spike_train_synchrony/ spike_contrast Synchrotool -:copyright: Copyright 2015-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals diff --git a/elephant/sta.py b/elephant/sta.py index 47ba74197..0bb5dbc3c 100644 --- a/elephant/sta.py +++ b/elephant/sta.py @@ -1,19 +1,27 @@ # -*- coding: utf-8 -*- -''' +""" Functions to calculate spike-triggered average and spike-field coherence of analog signals. -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +.. autosummary:: + :toctree: _toctree/sta + + spike_triggered_average + spike_field_coherence + +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. -''' +""" from __future__ import division, print_function, unicode_literals +import warnings + import numpy as np -import scipy.signal import quantities as pq +import scipy.signal from neo.core import AnalogSignal, SpikeTrain -import warnings + from .conversion import BinnedSpikeTrain __all__ = [ diff --git a/elephant/statistics.py b/elephant/statistics.py index e79f72bde..9bfdc154d 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -3,28 +3,11 @@ Statistical measures of spike trains (e.g., Fano factor) and functions to estimate firing rates. -Tutorial --------- - -:doc:`View tutorial <../tutorials/statistics>` - -Run tutorial interactively: - -.. image:: https://mybinder.org/badge.svg - :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master - ?filepath=doc/tutorials/statistics.ipynb - - -.. current_module elephant.statistics - -Functions overview ------------------- - Rate estimation -~~~~~~~~~~~~~~~ +*************** .. autosummary:: - :toctree: toctree/statistics/ + :toctree: _toctree/statistics/ mean_firing_rate instantaneous_rate @@ -33,10 +16,10 @@ Spike interval statistics -~~~~~~~~~~~~~~~~~~~~~~~~~ +************************* .. autosummary:: - :toctree: toctree/statistics/ + :toctree: _toctree/statistics/ isi cv @@ -46,15 +29,37 @@ Statistics across spike trains -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +****************************** .. autosummary:: - :toctree: toctree/statistics/ + :toctree: _toctree/statistics/ fanofactor complexity_pdf Complexity + +Tutorial +******** + +:doc:`View tutorial <../tutorials/statistics>` + +Run tutorial interactively: + +.. image:: https://mybinder.org/badge.svg + :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master + ?filepath=doc/tutorials/statistics.ipynb + + +References +---------- + +.. bibliography:: ../bib/elephant.bib + :labelprefix: st + :keyprefix: statistics- + :style: unsrt + + :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -115,7 +120,7 @@ def isi(spiketrain, axis=-1): The spike times. axis : int, optional The axis along which the difference is taken. - Default: the last axis. + Default: the last axis Returns ------- @@ -128,6 +133,12 @@ def isi(spiketrain, axis=-1): When the input array is not sorted, negative intervals are returned with a warning. + Examples + -------- + >>> from elephant import statistics + >>> statistics.isi([0.3, 4.5, 6.7, 9.3]) + array([4.2, 2.2, 2.6]) + """ if isinstance(spiketrain, neo.SpikeTrain): intervals = np.diff(spiketrain.magnitude, axis=axis) @@ -166,19 +177,19 @@ def mean_firing_rate(spiketrain, t_start=None, t_stop=None, axis=None): If None, retrieved from the `t_start` attribute of `spiketrain`. If that is not present, default to 0. All spiketrain's spike times below this value are ignored. - Default: None. + Default: None t_stop : float or pq.Quantity, optional The stop time to use for the time points. If not specified, retrieved from the `t_stop` attribute of `spiketrain`. If that is not present, default to the maximum value of `spiketrain`. All spiketrain's spike times above this value are ignored. - Default: None. + Default: None axis : int, optional The axis over which to do the calculation; has no effect when the input is a neo.SpikeTrain, because a neo.SpikeTrain is always a 1-d vector. If None, do the calculation over the flattened array. - Default: None. + Default: None Returns ------- @@ -196,6 +207,12 @@ def mean_firing_rate(spiketrain, t_start=None, t_stop=None, axis=None): ValueError If the input spiketrain is empty. + Examples + -------- + >>> from elephant import statistics + >>> statistics.mean_firing_rate([0.3, 4.5, 6.7, 9.3]) + 0.4301075268817204 + """ if isinstance(spiketrain, neo.SpikeTrain) and t_start is None \ and t_stop is None and axis is None: @@ -227,7 +244,6 @@ def mean_firing_rate(spiketrain, t_start=None, t_stop=None, axis=None): t_stop=t_stop, axis=axis) rates = pq.Quantity(rates, units=1. / units) - return rates elif isinstance(spiketrain, (np.ndarray, list, tuple)): if isinstance(t_start, pq.Quantity) or isinstance(t_stop, pq.Quantity): raise TypeError("'t_start' and 't_stop' cannot be quantities if " @@ -244,11 +260,11 @@ def mean_firing_rate(spiketrain, t_start=None, t_stop=None, axis=None): t_stop = np.expand_dims(t_stop, axis) rates = np.sum((spiketrain >= t_start) & (spiketrain <= t_stop), axis=axis) / time_interval - return rates else: raise TypeError("Invalid input spiketrain type: '{}'. Allowed: " "neo.SpikeTrain, Quantity, ndarray". format(type(spiketrain))) + return rates def fanofactor(spiketrains, warn_tolerance=0.1 * pq.ms): @@ -276,7 +292,7 @@ def fanofactor(spiketrains, warn_tolerance=0.1 * pq.ms): In case of a list of input neo.SpikeTrains, if their durations vary by more than `warn_tolerence` in their absolute values, throw a warning (see Notes). - Default: 0.1 ms. + Default: 0.1 ms Returns ------- @@ -296,6 +312,18 @@ def fanofactor(spiketrains, warn_tolerance=0.1 * pq.ms): The check for the equal duration of the input spike trains is performed only if the input is of type`neo.SpikeTrain`: if you pass a numpy array, please make sure that they all have the same duration manually. + + Examples + -------- + >>> import neo + >>> from elephant import statistics + >>> spiketrains = [ + ... neo.SpikeTrain([0.3, 4.5, 6.7, 9.3], t_stop=10, units='s'), + ... neo.SpikeTrain([1.4, 3.3, 8.2], t_stop=10, units='s') + ... ] + >>> statistics.fanofactor(spiketrains) + 0.07142857142857142 + """ # Build array of spike counts (one per spike train) spike_counts = np.array([len(st) for st in spiketrains]) @@ -335,10 +363,9 @@ def __variation_check(v, with_nan): "an input with more than 1 entry. Returning `NaN`" "since the argument `with_nan` is `True`") return np.NaN - else: - raise ValueError("Input size is too small. Please provide " - "an input with more than 1 entry. Set 'with_nan' " - "to True to replace the error by a warning.") + raise ValueError("Input size is too small. Please provide " + "an input with more than 1 entry. Set 'with_nan' " + "to True to replace the error by a warning.") return None @@ -347,7 +374,7 @@ def __variation_check(v, with_nan): def cv2(time_intervals, with_nan=False): r""" Calculate the measure of Cv2 for a sequence of time intervals between - events. + events :cite:`statistics-Holt1996_1806`. Given a vector :math:`I` containing a sequence of intervals, the Cv2 is defined as: @@ -371,7 +398,7 @@ def cv2(time_intervals, with_nan=False): np.NaN value and a warning is raised. If False, `ValueError` exception is raised with a spike train with less than two spikes. - Default: True. + Default: True Returns ------- @@ -393,12 +420,11 @@ def cv2(time_intervals, with_nan=False): If `with_nan` is True and `cv2` is calculated for a sequence with less than two entries, generating a np.NaN. - References - ---------- - .. [1] G. R. Holt, W. R. Softky, C. Koch, & R. J. Douglas, "Comparison of - discharge variability in vitro and in vivo in cat visual cortex - neurons," Journal of Neurophysiology, vol. 75, no. 5, pp. 1806-1814, - 1996. + Examples + -------- + >>> from elephant import statistics + >>> statistics.cv2([0.3, 4.5, 6.7, 9.3]) + 0.8226190476190478 """ # convert to array, cast to float @@ -416,7 +442,7 @@ def cv2(time_intervals, with_nan=False): def lv(time_intervals, with_nan=False): r""" Calculate the measure of local variation Lv for a sequence of time - intervals between events. + intervals between events :cite:`statistics-Shinomoto2003_2823`. Given a vector :math:`I` containing a sequence of intervals, the Lv is defined as: @@ -440,7 +466,7 @@ def lv(time_intervals, with_nan=False): `np.NaN` value and a warning is raised. If False, a `ValueError` exception is raised with a spike train with less than two spikes. - Default: True. + Default: True Returns ------- @@ -462,11 +488,11 @@ def lv(time_intervals, with_nan=False): If `with_nan` is True and the Lv is calculated for a spike train with less than two spikes, generating a np.NaN. - References - ---------- - .. [1] S. Shinomoto, K. Shima, & J. Tanji, "Differences in spiking - patterns among cortical neurons," Neural Computation, vol. 15, - pp. 2823–2842, 2003. + Examples + -------- + >>> from elephant import statistics + >>> statistics.lv([0.3, 4.5, 6.7, 9.3]) + 0.8306154336734695 """ # convert to array, cast to float @@ -482,7 +508,7 @@ def lv(time_intervals, with_nan=False): def lvr(time_intervals, R=5*pq.ms, with_nan=False): r""" Calculate the measure of revised local variation LvR for a sequence of time - intervals between events. + intervals between events :cite:`statistics-Shinomoto2009_e1000433`. Given a vector :math:`I` containing a sequence of intervals, the LvR is defined as: @@ -496,7 +522,8 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): The LvR is a revised version of the Lv, with enhanced invariance to firing rate fluctuations by introducing a refractoriness constant R. The LvR with `R=5ms` was shown to outperform other ISI variability measures in spike - trains with firing rate fluctuatins and sensory stimuli [1]_. + trains with firing rate fluctuations and sensory stimuli + :cite:`statistics-Shinomoto2009_e1000433`. Parameters ---------- @@ -506,13 +533,13 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): R : pq.Quantity or int or float Refractoriness constant (R >= 0). If no quantity is passed `ms` are assumed. - Default: 5 ms. + Default: 5 ms with_nan : bool, optional If True, LvR of a spike train with less than two spikes results in a np.NaN value and a warning is raised. If False, a `ValueError` exception is raised with a spike train with less than two spikes. - Default: True. + Default: True Returns ------- @@ -535,12 +562,11 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): with less than two spikes, generating a np.NaN. If R is passed without any units attached milliseconds are assumed. - References - ---------- - .. [1] S. Shinomoto, H. Kim, T. Shimokawa et al. "Relating Neuronal Firing - Patterns to Functional Differentiation of Cerebral Cortex" PLOS - Computational Biology 5(7): e1000433, 2009. - + Examples + -------- + >>> from elephant import statistics + >>> statistics.lvr([0.3, 4.5, 6.7, 9.3], R=0.005) + 0.833907445980624 """ if isinstance(R, pq.Quantity): R = R.rescale('ms').magnitude @@ -598,25 +624,26 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. If 'auto', the optimized kernel width for the rate estimation is - calculated according to [1]_ and with this width a gaussian kernel is - constructed. Automatized calculation of the kernel width is not - available for other than gaussian kernel shapes. - Default: 'auto'. + calculated according to :cite:`statistics-Shimazaki2010_171` and with + this width a gaussian kernel is constructed. Automatized calculation + of the kernel width is not available for other than gaussian kernel + shapes. + Default: 'auto' cutoff : float, optional This factor determines the cutoff of the probability distribution of the kernel, i.e., the considered width of the kernel in terms of multiples of the standard deviation sigma. - Default: 5.0. + Default: 5.0 t_start : pq.Quantity, optional Start time of the interval used to compute the firing rate. If None, `t_start` is assumed equal to `t_start` attribute of `spiketrain`. - Default: None. + Default: None t_stop : pq.Quantity, optional End time of the interval used to compute the firing rate (included). If None, `t_stop` is assumed equal to `t_stop` attribute of `spiketrain`. - Default: None. + Default: None trim : bool, optional Accounts for the asymmetry of a kernel. If False, the output of the Fast Fourier Transformation being a longer @@ -630,7 +657,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Transformation by a total of two times the size of the kernel, and `t_start` and `t_stop` are adjusted. True (trimming) is equivalent to 'valid' convolution mode for symmetrical kernels. - Default: False. + Default: False center_kernel : bool, optional If set to True, the kernel will be translated such that its median is centered on the spike, thus putting equal weight before and after the @@ -680,21 +707,52 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', The resulting instantaneous firing rate values smaller than ``0``, which can happen due to machine precision errors, are clipped to zero. - References - ---------- - .. [1] H. Shimazaki, & S. Shinomoto, "Kernel bandwidth optimization in - spike rate estimation," J Comput Neurosci, vol. 29, pp. 171–182, - 2010. - Examples -------- + Example 1. Automatic kernel estimation. + + >>> import neo >>> import quantities as pq + >>> from elephant import statistics + >>> spiketrain = neo.SpikeTrain([0.3, 4.5, 6.7, 9.3], t_stop=10, units='s') + >>> rate = statistics.instantaneous_rate(spiketrain, + ... sampling_period=10 * pq.ms, + ... kernel='auto') + >>> rate + AnalogSignal with 1 channels of length 1000; units Hz; datatype float64 + annotations: {'t_stop': array(10.) * s, + 'kernel': {'type': 'GaussianKernel', + 'sigma': '7.273225922958104 s', + 'invert': False}} + sampling rate: 0.1 1/ms + time: 0.0 s to 10.0 s + + Example 2. Manually set kernel. + >>> from elephant import kernels - >>> from elephant.spike_train_generation import homogeneous_poisson_process - >>> spiketrain = homogeneous_poisson_process(rate=10*pq.Hz, t_stop=5*pq.s) - >>> kernel = kernels.AlphaKernel(sigma=0.05*pq.s, invert=True) - >>> rate = instantaneous_rate(spiketrain, sampling_period=2*pq.ms, - ... kernel=kernel) + >>> spiketrain = neo.SpikeTrain([0], t_stop=1, units='s') + >>> kernel = kernels.GaussianKernel(sigma=300 * pq.ms) + >>> rate = statistics.instantaneous_rate(spiketrain, + ... sampling_period=200 * pq.ms, kernel=kernel, t_start=-1 * pq.s) + >>> rate + AnalogSignal with 1 channels of length 10; units Hz; datatype float64 + annotations: {'t_stop': array(1.) * s, + 'kernel': {'type': 'GaussianKernel', + 'sigma': '300.0 ms', + 'invert': False}} + sampling rate: 0.005 1/ms + time: -1.0 s to 1.0 s + >>> rate.magnitude + array([[0.01007419], + [0.05842767], + [0.22928759], + [0.60883028], + [1.0938699 ], + [1.3298076 ], + [1.0938699 ], + [0.60883028], + [0.22928759], + [0.05842767]]) """ def optimal_kernel(st): @@ -912,6 +970,25 @@ def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, -------- elephant.conversion.BinnedSpikeTrain + Examples + -------- + >>> import neo + >>> import quantities as pq + >>> from elephant import statistics + >>> spiketrains = [ + ... neo.SpikeTrain([0.3, 4.5, 6.7, 9.3], t_stop=10, units='s'), + ... neo.SpikeTrain([0.7, 4.3, 8.2], t_stop=10, units='s') + ... ] + >>> hist = statistics.time_histogram(spiketrains, bin_size=1 * pq.s) + >>> hist + AnalogSignal with 1 channels of length 10; units dimensionless; datatype + int64 + annotations: {'normalization': 'counts'} + sampling rate: 1.0 1/s + time: 0.0 s to 10.0 s + >>> hist.magnitude.flatten() + array([2, 0, 0, 0, 2, 0, 1, 0, 1, 1]) + """ # Bin the spike trains and sum across columns bs = BinnedSpikeTrain(spiketrains, t_start=t_start, t_stop=t_stop, @@ -945,10 +1022,10 @@ def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, @deprecated_alias(binsize='bin_size') def complexity_pdf(spiketrains, bin_size): """ - Deprecated in favor of the complexity class which has a pdf attribute. - Will be removed in the next release! + Complexity Distribution of a list of `neo.SpikeTrain` objects + :cite:`statistics-Gruen2007_96`. - Complexity Distribution of a list of `neo.SpikeTrain` objects. + Deprecated in favor of :meth:`Complexity.pdf`. Probability density computed from the complexity histogram which is the histogram of the entries of the population histogram of clipped (binary) @@ -957,8 +1034,6 @@ def complexity_pdf(spiketrains, bin_size): number of occurrences. The normalization of that histogram to 1 is the probability density. - Implementation is based on [1]_. - Parameters ---------- spiketrains : list of neo.SpikeTrain @@ -976,18 +1051,9 @@ def complexity_pdf(spiketrains, bin_size): See also -------- elephant.conversion.BinnedSpikeTrain - - References - ---------- - .. [1] S. Gruen, M. Abeles, & M. Diesmann, "Impact of higher-order - correlations on coincidence distributions of massively parallel - data," In "Dynamic Brain - from Neural Spikes to Behaviors", - pp. 96-114, Springer Berlin Heidelberg, 2008. - """ - warnings.warn("complexity_pdf is deprecated in favor of the complexity " - "class which has a pdf attribute. complexity_pdf will be " - "removed in the next Elephant release.", DeprecationWarning) + warnings.warn("'complexity_pdf' is deprecated in favor of the Complexity " + "class which has a 'pdf' method", DeprecationWarning) complexity = Complexity(spiketrains, bin_size=bin_size) @@ -997,13 +1063,13 @@ def complexity_pdf(spiketrains, bin_size): class Complexity(object): """ Class for complexity distribution (i.e. number of synchronous spikes found) - of a list of `neo.SpikeTrain` objects. + :cite:`statistics-Gruen2007_96` of a list of `neo.SpikeTrain` objects. Complexity is calculated by counting the number of spikes (i.e. non-empty bins) that occur separated by `spread - 1` or less empty bins, within and across spike trains in the `spiketrains` list. - Implementation (without spread) is based on [1]_. + Implementation (without spread) is based on the cited above paper. Parameters ---------- @@ -1105,27 +1171,19 @@ class Complexity(object): elephant.conversion.BinnedSpikeTrain elephant.spike_train_synchrony.Synchrotool - References - ---------- - .. [1] S. Gruen, M. Abeles, & M. Diesmann, "Impact of higher-order - correlations on coincidence distributions of massively parallel - data," In "Dynamic Brain - from Neural Spikes to Behaviors", - pp. 96-114, Springer Berlin Heidelberg, 2008. - Examples -------- >>> import neo >>> import quantities as pq >>> from elephant.statistics import Complexity - >>> sr = 1/pq.ms - + >>> sampling_rate = 1/pq.ms >>> st1 = neo.SpikeTrain([1, 4, 6] * pq.ms, t_stop=10.0 * pq.ms) >>> st2 = neo.SpikeTrain([1, 5, 8] * pq.ms, t_stop=10.0 * pq.ms) >>> sts = [st1, st2] >>> # spread = 0, a simple bincount - >>> cpx = Complexity(sts, sampling_rate=sr) + >>> cpx = Complexity(sts, sampling_rate=sampling_rate) Complexity calculated at sampling rate precision >>> print(cpx.complexity_histogram) [5 4 1] @@ -1135,7 +1193,7 @@ class Complexity(object): [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] ms >>> # spread = 1, consecutive spikes - >>> cpx = Complexity(sts, sampling_rate=sr, spread=1) + >>> cpx = Complexity(sts, sampling_rate=sampling_rate, spread=1) Complexity calculated at sampling rate precision >>> print(cpx.complexity_histogram) [5 4 1] @@ -1143,12 +1201,22 @@ class Complexity(object): [0 2 0 0 3 3 3 0 1 0] dimensionless >>> # spread = 2, consecutive spikes and separated by 1 empty bin - >>> cpx = Complexity(sts, sampling_rate=sr, spread=2) + >>> cpx = Complexity(sts, sampling_rate=sampling_rate, spread=2) Complexity calculated at sampling rate precision >>> print(cpx.complexity_histogram) [4 0 1 0 1] >>> print(cpx.time_histogram.flatten()) [0 2 0 0 4 4 4 4 4 0] dimensionless + >>> pdf = cpx.pdf() + >>> pdf + AnalogSignal with 1 channels of length 3; units dimensionless; + datatype float64 + sampling rate: 1.0 dimensionless + time: 0.0 dimensionless to 3.0 dimensionless + >>> pdf.magnitude + array([[0.5], + [0.4], + [0.1]]) """ def __init__(self, spiketrains, @@ -1369,20 +1437,6 @@ def _epoch_with_spread(self): return complexity_epoch -""" -Kernel Bandwidth Optimization. - -Python implementation by Subhasis Ray. - -Original matlab code (sskernel.m) here: -http://2000.jukuin.keio.ac.jp/shimazaki/res/kernel.html - -This was translated into Python by Subhasis Ray, NCBS. Tue Jun 10 -23:01:43 IST 2014 - -""" - - def nextpow2(x): """ Return the smallest integral power of 2 that is equal or larger than `x`. @@ -1466,26 +1520,31 @@ def cost_function(x, N, w, dt): def optimal_kernel_bandwidth(spiketimes, times=None, bandwidth=None, bootstrap=False): """ - Calculates optimal fixed kernel bandwidth, given as the standard deviation + Calculates optimal fixed kernel bandwidth + :cite:`statistics-Shimazaki2010_171`, given as the standard deviation sigma. + Original matlab code (sskernel.m) + http://2000.jukuin.keio.ac.jp/shimazaki/res/kernel.html has been ported to + Python by Subhasis Ray, NCBS. + Parameters ---------- spiketimes : np.ndarray Sequence of spike times (sorted to be ascending). - times : np.ndarray, optional + times : np.ndarray or None, optional Time points at which the kernel bandwidth is to be estimated. If None, `spiketimes` is used. - Default: None. - bandwidth : np.ndarray, optional + Default: None + bandwidth : np.ndarray or None, optional Vector of kernel bandwidths (standard deviation sigma). If specified, optimal bandwidth is selected from this. If None, `bandwidth` is obtained through a golden-section search on a log-exp scale. - Default: None. + Default: None bootstrap : bool, optional If True, calculates the 95% confidence interval using Bootstrap. - Default: False. + Default: False Returns ------- @@ -1510,12 +1569,6 @@ def optimal_kernel_bandwidth(spiketimes, times=None, bandwidth=None, If no optimal kernel could be found, all entries of the dictionary are set to None. - References - ---------- - .. [1] H. Shimazaki, & S. Shinomoto, "Kernel bandwidth optimization in - spike rate estimation," Journal of Computational Neuroscience, - vol. 29, no. 1-2, pp. 171-82, 2010. doi:10.1007/s10827-009-0180-4. - """ if times is None: diff --git a/elephant/test/make_spike_extraction_test_data.py b/elephant/test/make_spike_extraction_test_data.py index c17a4c5a4..4a72983d6 100644 --- a/elephant/test/make_spike_extraction_test_data.py +++ b/elephant/test/make_spike_extraction_test_data.py @@ -14,15 +14,15 @@ def main(): # pragma: no cover I = 4 * mvolt / ms # Standard Izhikevich neuron equations. - eqs = ''' + eqs = """ dv/dt = 0.04*v**2/(ms*mvolt) + (5/ms)*v + 140*mvolt/ms - u + I : volt du/dt = a*((b*v) - u) : volt/second - ''' + """ - reset = ''' + reset = """ v = c u += d - ''' + """ # Setup and run simulation. G = NeuronGroup(1, eqs, threshold='v>30*mvolt', reset='v = -70*mvolt') diff --git a/elephant/test/test_asset.py b/elephant/test/test_asset.py index b8f47ff49..b6a38f9c1 100644 --- a/elephant/test/test_asset.py +++ b/elephant/test/test_asset.py @@ -2,7 +2,7 @@ """ Unit tests for the ASSET analysis. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_cell_assembly_detection.py b/elephant/test/test_cell_assembly_detection.py index 0f31c8ca4..64d7ad771 100644 --- a/elephant/test/test_cell_assembly_detection.py +++ b/elephant/test/test_cell_assembly_detection.py @@ -110,39 +110,23 @@ def test_cad_single_sip(self): # check neurons in the pattern assert_array_equal(sorted(output_single[0]['neurons']), self.elements1) - # check the occurrences time of the patter + # check the occurrences time of the pattern assert_array_equal(output_single[0]['times'], - self.occ1) + self.occ1 * self.bin_size) # check the lags - assert_array_equal(sorted(output_single[0]['lags']), - self.output_lags1) + assert_array_equal(sorted(output_single[0]['lags']) * pq.s, + self.output_lags1 * self.bin_size) # test with multiple (3) patterns injected in the data def test_cad_msip(self): # collecting cad output output_msip = cad.cell_assembly_detection( binned_spiketrain=self.msip, max_lag=self.max_lag) - - elements_msip = [] - occ_msip = [] - lags_msip = [] - for out in output_msip: - elements_msip.append(out['neurons']) - occ_msip.append(out['times']) - lags_msip.append(list(out['lags'])) - elements_msip = sorted(elements_msip, key=lambda d: len(d)) - occ_msip = sorted(occ_msip, key=lambda d: len(d)) - lags_msip = sorted(lags_msip, key=lambda d: len(d)) - elements_msip = [sorted(e) for e in elements_msip] - # check neurons in the patterns - assert_array_equal(elements_msip, self.elements_msip) - # check the occurrences time of the patters - assert_array_equal(occ_msip[0], self.occ_msip[0]) - assert_array_equal(occ_msip[1], self.occ_msip[1]) - assert_array_equal(occ_msip[2], self.occ_msip[2]) - lags_msip = [sorted(e) for e in lags_msip] - # check the lags - assert_array_equal(lags_msip, self.lags_msip) + for i, out in enumerate(output_msip): + assert_array_equal(out['times'], self.occ_msip[i] * self.bin_size) + assert_array_equal(sorted(out['lags']) * pq.s, + self.lags_msip[i] * self.bin_size) + assert_array_equal(sorted(out['neurons']), self.elements_msip[i]) # test the errors raised def test_cad_raise_error(self): diff --git a/elephant/test/test_change_point_detection.py b/elephant/test/test_change_point_detection.py index 57e197cf5..6fce25cac 100644 --- a/elephant/test/test_change_point_detection.py +++ b/elephant/test/test_change_point_detection.py @@ -1,22 +1,19 @@ # -*- coding: utf-8 -*- +import unittest + import neo import numpy as np import quantities as pq +from numpy.testing import assert_array_almost_equal, assert_allclose -import unittest import elephant.change_point_detection as mft -from numpy.testing.utils import assert_array_almost_equal, assert_allclose - -# np.random.seed(13) class FilterTestCase(unittest.TestCase): def setUp(self): self.test_array = [0.4, 0.5, 0.65, 0.7, 0.9, 1.15, 1.2, 1.9] - ''' - spks_ri = [0.9, 1.15, 1.2] - spk_le = [0.4, 0.5, 0.65, 0.7] - ''' + # spks_ri = [0.9, 1.15, 1.2] + # spk_le = [0.4, 0.5, 0.65, 0.7] mu_ri = (0.25 + 0.05) / 2 mu_le = (0.1 + 0.15 + 0.05) / 3 sigma_ri = ((0.25 - 0.15) ** 2 + (0.05 - 0.15) ** 2) / 2 @@ -24,7 +21,7 @@ def setUp(self): 0.05 - 0.1) ** 2) / 3 self.targ_t08_h025 = 0 self.targ_t08_h05 = (3 - 4) / np.sqrt( - (sigma_ri / mu_ri ** (3)) * 0.5 + (sigma_le / mu_le ** (3)) * 0.5) + (sigma_ri / mu_ri ** 3) * 0.5 + (sigma_le / mu_le ** 3) * 0.5) # Window Large # def test_filter_with_spiketrain_h05(self): @@ -156,13 +153,6 @@ def test_MultipleFilterAlgorithm_with_quantities_h05(self): target = [self.targ_h05_dt05] res = mft.multiple_filter_test([0.5] * pq.s, st, 2.1 * pq.s, 5, 100, time_step=0.5 * pq.s) - assert_array_almost_equal(res, target, decimal=9) - - def test_MultipleFilterAlgorithm_with_plain_array_h05(self): - st = self.test_array - target = [self.targ_h05_dt05] - res = mft.multiple_filter_test([0.5] * pq.s, st * pq.s, 2.1 * pq.s, 5, - 100, time_step=0.5 * pq.s) self.assertNotIsInstance(res, pq.Quantity) assert_array_almost_equal(res, target, decimal=9) diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index a540228ec..db5cae06e 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -2,7 +2,7 @@ """ Unit tests for the conversion module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -514,10 +514,10 @@ def test_get_start_stop(self): b = neo.SpikeTrain( [-0.1, -0.7, 1.2, 2.2, 4.3, 5.5, 8.0] * pq.s, t_start=-1 * pq.s, t_stop=8 * pq.s) - start, stop = cv.get_common_start_stop_times(a) + start, stop = get_common_start_stop_times(a) self.assertEqual(start, a.t_start) self.assertEqual(stop, a.t_stop) - start, stop = cv.get_common_start_stop_times([a, b]) + start, stop = get_common_start_stop_times([a, b]) self.assertEqual(start, a.t_start) self.assertEqual(stop, b.t_stop) diff --git a/elephant/test/test_cubic.py b/elephant/test/test_cubic.py index cb2639c25..31938a265 100644 --- a/elephant/test/test_cubic.py +++ b/elephant/test/test_cubic.py @@ -2,7 +2,7 @@ """ Unit tests for the CUBIC analysis. -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -16,20 +16,16 @@ class CubicTestCase(unittest.TestCase): - ''' + """ This test is constructed to check the implementation of the CuBIC - method [1]. + method :cite:`cubic-Staude2010_327`. In the setup function is constructed an neo.AnalogSignal, that represents the Population Histogram of a population of neurons with order - of correlation equal to ten. Since the population contu is either equal to + of correlation equal to ten. Since the population count is either equal to 0 or 10 means that the embedded order of correlation is exactly 10. In test_cubic() the format of all the output and the order of correlation - of the function jelephant.cubic.cubic() are tested. - - References - ---------- - [1]Staude, Rotter, Gruen, (2009) J. Comp. Neurosci - ''' + of the function `elephant.cubic.cubic()` are tested. + """ def setUp(self): n2 = 300 diff --git a/elephant/test/test_gpfa.py b/elephant/test/test_gpfa.py index d4dc90745..a571ed3d8 100644 --- a/elephant/test/test_gpfa.py +++ b/elephant/test/test_gpfa.py @@ -2,7 +2,7 @@ """ Unit tests for the GPFA analysis. -:copyright: Copyright 2014-2016 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_icsd.py b/elephant/test/test_icsd.py index 764fcf7a3..4553b109a 100644 --- a/elephant/test/test_icsd.py +++ b/elephant/test/test_icsd.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- -''' +""" iCSD testing suite -''' +""" import os import numpy as np @@ -32,7 +32,7 @@ def potential_of_plane(z_j, z_i=0. * pq.m, C_i=1 * pq.A / pq.m**2, sigma=0.3 * pq.S / pq.m): - ''' + """ Return potential of infinite horizontal plane with constant current source density at a vertical offset z_j. @@ -52,7 +52,7 @@ def potential_of_plane(z_j, z_i=0. * pq.m, The potential is 0 at the plane, as the potential goes to infinity for large distances - ''' + """ try: assert(z_j.units == z_i.units) except AssertionError as ae: @@ -68,7 +68,7 @@ def potential_of_disk(z_j, C_i=1 * pq.A / pq.m**2, R_i=1E-3 * pq.m, sigma=0.3 * pq.S / pq.m): - ''' + """ Return potential of circular disk in horizontal plane with constant current source density at a vertical offset z_j. @@ -84,7 +84,7 @@ def potential_of_disk(z_j, radius of disk source sigma : float*pq.S/pq.m conductivity of medium in units of S/m - ''' + """ try: assert(z_j.units == z_i.units == R_i.units) except AssertionError as ae: @@ -103,7 +103,7 @@ def potential_of_cylinder(z_j, h_i=0.1 * pq.m, sigma=0.3 * pq.S / pq.m, ): - ''' + """ Return potential of cylinder in horizontal plane with constant homogeneous current source density at a vertical offset z_j. @@ -136,7 +136,7 @@ def potential_of_cylinder(z_j, ... abs(z-z_j)), (z, z_i-h/2, z_i+h/2)) - ''' + """ try: assert(z_j.units == z_i.units == R_i.units == h_i.units) except AssertionError as ae: @@ -165,10 +165,10 @@ def get_lfp_of_planes(z_j=np.arange(21) * 1E-4 * pq.m, C_i=np.array([-.5, 1., -.5]) * pq.A / pq.m**2, sigma=0.3 * pq.S / pq.m, plot=True): - ''' + """ Compute the lfp of spatially separated planes with given current source density - ''' + """ phi_j = np.zeros(z_j.size) * pq.V for i, (zi, Ci) in enumerate(zip(z_i, C_i)): for j, zj in enumerate(z_j): @@ -204,10 +204,10 @@ def get_lfp_of_disks(z_j=np.arange(21) * 1E-4 * pq.m, R_i=np.array([1, 1, 1]) * 1E-3 * pq.m, sigma=0.3 * pq.S / pq.m, plot=True): - ''' + """ Compute the lfp of spatially separated disks with a given current source density - ''' + """ phi_j = np.zeros(z_j.size) * pq.V for i, (zi, Ci, Ri) in enumerate(zip(z_i, C_i, R_i)): for j, zj in enumerate(z_j): @@ -244,10 +244,10 @@ def get_lfp_of_cylinders(z_j=np.arange(21) * 1E-4 * pq.m, h_i=np.array([1, 1, 1]) * 1E-4 * pq.m, sigma=0.3 * pq.S / pq.m, plot=True): - ''' + """ Compute the lfp of spatially separated disks with a given current source density - ''' + """ phi_j = np.zeros(z_j.size) * pq.V for i, (zi, Ci, Ri, hi) in enumerate(zip(z_i, C_i, R_i, h_i)): for j, zj in enumerate(z_j): @@ -279,13 +279,13 @@ def get_lfp_of_cylinders(z_j=np.arange(21) * 1E-4 * pq.m, class TestICSD(unittest.TestCase): - ''' + """ Set of test functions for each CSD estimation method comparing estimate to LFPs calculated with known ground truth CSD - ''' + """ def test_StandardCSD_00(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates. # contact point coordinates @@ -320,7 +320,7 @@ def test_StandardCSD_00(self): nt.assert_array_almost_equal(C_i, csd) def test_StandardCSD_01(self): - '''test using non-standard SI units 1''' + """test using non-standard SI units 1""" # set some parameters for ground truth csd and csd estimates. # contact point coordinates @@ -355,7 +355,7 @@ def test_StandardCSD_01(self): nt.assert_array_almost_equal(C_i, csd) def test_StandardCSD_02(self): - '''test using non-standard SI units 2''' + """test using non-standard SI units 2""" # set some parameters for ground truth csd and csd estimates. # contact point coordinates @@ -390,7 +390,7 @@ def test_StandardCSD_02(self): nt.assert_array_almost_equal(C_i, csd) def test_StandardCSD_03(self): - '''test using non-standard SI units 3''' + """test using non-standard SI units 3""" # set some parameters for ground truth csd and csd estimates. # contact point coordinates @@ -425,7 +425,7 @@ def test_StandardCSD_03(self): nt.assert_array_almost_equal(C_i, csd) def test_DeltaiCSD_00(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -469,7 +469,7 @@ def test_DeltaiCSD_00(self): nt.assert_array_almost_equal(C_i, csd) def test_DeltaiCSD_01(self): - '''test using non-standard SI units 1''' + """test using non-standard SI units 1""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -513,7 +513,7 @@ def test_DeltaiCSD_01(self): nt.assert_array_almost_equal(C_i, csd) def test_DeltaiCSD_02(self): - '''test using non-standard SI units 2''' + """test using non-standard SI units 2""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -557,7 +557,7 @@ def test_DeltaiCSD_02(self): nt.assert_array_almost_equal(C_i, csd) def test_DeltaiCSD_03(self): - '''test using non-standard SI units 3''' + """test using non-standard SI units 3""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -602,7 +602,7 @@ def test_DeltaiCSD_03(self): nt.assert_array_almost_equal(C_i, csd) def test_DeltaiCSD_04(self): - '''test non-continous z_j array''' + """test non-continous z_j array""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -647,7 +647,7 @@ def test_DeltaiCSD_04(self): nt.assert_array_almost_equal(C_i[inds], csd) def test_StepiCSD_units_00(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -696,7 +696,7 @@ def test_StepiCSD_units_00(self): nt.assert_array_almost_equal(C_i, csd) def test_StepiCSD_01(self): - '''test using non-standard SI units 1''' + """test using non-standard SI units 1""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -745,7 +745,7 @@ def test_StepiCSD_01(self): nt.assert_array_almost_equal(C_i, csd) def test_StepiCSD_02(self): - '''test using non-standard SI units 2''' + """test using non-standard SI units 2""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -794,7 +794,7 @@ def test_StepiCSD_02(self): nt.assert_array_almost_equal(C_i, csd) def test_StepiCSD_03(self): - '''test using non-standard SI units 3''' + """test using non-standard SI units 3""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -843,7 +843,7 @@ def test_StepiCSD_03(self): nt.assert_array_almost_equal(C_i, csd) def test_StepiCSD_units_04(self): - '''test non-continous z_j array''' + """test non-continous z_j array""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -892,7 +892,7 @@ def test_StepiCSD_units_04(self): nt.assert_array_almost_equal(C_i[inds], csd) def test_SplineiCSD_00(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -954,7 +954,7 @@ def test_SplineiCSD_00(self): nt.assert_array_almost_equal(C_i, csd, decimal=3) def test_SplineiCSD_01(self): - '''test using standard SI units, deep electrode coordinates''' + """test using standard SI units, deep electrode coordinates""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -1016,7 +1016,7 @@ def test_SplineiCSD_01(self): nt.assert_array_almost_equal(C_i, csd, decimal=3) def test_SplineiCSD_02(self): - '''test using non-standard SI units''' + """test using non-standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -1078,7 +1078,7 @@ def test_SplineiCSD_02(self): nt.assert_array_almost_equal(C_i, csd, decimal=3) def test_SplineiCSD_03(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -1140,7 +1140,7 @@ def test_SplineiCSD_03(self): nt.assert_array_almost_equal(C_i, csd, decimal=3) def test_SplineiCSD_04(self): - '''test using standard SI units''' + """test using standard SI units""" # set some parameters for ground truth csd and csd estimates., e.g., # we will use same source diameter as in ground truth @@ -1203,7 +1203,7 @@ def test_SplineiCSD_04(self): # def suite(verbosity=2): -# ''' +# """ # Run unittests for the CSD toolbox # # @@ -1212,7 +1212,7 @@ def test_SplineiCSD_04(self): # verbosity : int # verbosity level # -# ''' +# """ # suite = unittest.TestLoader().loadTestsFromTestCase(TestICSD) # unittest.TextTestRunner(verbosity=verbosity).run(suite) # diff --git a/elephant/test/test_kernels.py b/elephant/test/test_kernels.py index 2f7242ceb..90577479a 100644 --- a/elephant/test/test_kernels.py +++ b/elephant/test/test_kernels.py @@ -2,7 +2,7 @@ """ Unit tests for the kernels module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index a3ce6edd6..39797785c 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -2,7 +2,7 @@ """ Unit tests for the neo_tools module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index b66b632bc..d1cd23261 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -2,7 +2,7 @@ """ Unit tests for the pandas bridge module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_phase_analysis.py b/elephant/test/test_phase_analysis.py index dfa94a690..ea996a3ae 100644 --- a/elephant/test/test_phase_analysis.py +++ b/elephant/test/test_phase_analysis.py @@ -2,7 +2,7 @@ """ Unit tests for the phase analysis module. -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function diff --git a/elephant/test/test_signal_processing.py b/elephant/test/test_signal_processing.py index 612ebc491..3596c375e 100644 --- a/elephant/test/test_signal_processing.py +++ b/elephant/test/test_signal_processing.py @@ -2,7 +2,7 @@ """ Unit tests for the signal_processing module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function @@ -29,11 +29,11 @@ class PairwiseCrossCorrelationTest(unittest.TestCase): freq = 1. * pq.Hz def test_cross_correlation_freqs(self): - ''' + """ Sine vs cosine for different frequencies Note, that accuracy depends on N and min(f). E.g., f=0.1 and N=2018 only has an accuracy on the order decimal=1 - ''' + """ freq_arr = np.linspace(0.5, 15, 8) * pq.Hz signal = np.zeros((self.n_samples, 3)) for freq in freq_arr: @@ -54,9 +54,9 @@ def test_cross_correlation_freqs(self): self.assertEqual(rho.shape, (signal.shape[0], 2)) # 2 pairs def test_cross_correlation_nlags(self): - ''' + """ Sine vs cosine for specific nlags - ''' + """ nlags = 30 signal = np.zeros((self.n_samples, 2)) signal[:, 0] = 0.2 * np.sin(2. * np.pi * self.freq * self.times) @@ -71,9 +71,9 @@ def test_cross_correlation_nlags(self): assert len(rho.times) == 2 * int(nlags) + 1 def test_cross_correlation_phi(self): - ''' + """ Sine with phase shift phi vs cosine - ''' + """ phi = np.pi / 6. signal = np.zeros((self.n_samples, 2)) signal[:, 0] = 0.2 * np.sin(2. * np.pi * self.freq * self.times + phi) @@ -89,9 +89,9 @@ def test_cross_correlation_phi(self): 2. * np.pi * self.freq * rho.times + phi), decimal=2) def test_cross_correlation_envelope(self): - ''' + """ Envelope of sine vs cosine - ''' + """ # Sine with phase shift phi vs cosine for different frequencies nlags = 800 # nlags need to be smaller than N/2 b/c border effects signal = np.zeros((self.n_samples, 2)) @@ -939,13 +939,13 @@ def setUp(self): t_stop=self.times[-1] * pq.s, sampling_period=(1 / self.fs) * pq.s) def test_derivative_invalid_signal(self): - '''Test derivative on non-AnalogSignal''' + """Test derivative on non-AnalogSignal""" kwds = {'signal': np.arange(5)} self.assertRaises( TypeError, elephant.signal_processing.derivative, **kwds) def test_derivative_units(self): - '''Test derivative returns AnalogSignal with correct units''' + """Test derivative returns AnalogSignal with correct units""" derivative = elephant.signal_processing.derivative( self.test_signal1) self.assertTrue(isinstance(derivative, neo.AnalogSignal)) @@ -954,7 +954,7 @@ def test_derivative_units(self): self.test_signal1.units / self.test_signal1.times.units) def test_derivative_times(self): - '''Test derivative returns AnalogSignal with correct times''' + """Test derivative returns AnalogSignal with correct times""" derivative = elephant.signal_processing.derivative( self.test_signal1) self.assertTrue(isinstance(derivative, neo.AnalogSignal)) @@ -976,7 +976,7 @@ def test_derivative_times(self): target_times[-1] + derivative.sampling_period) def test_derivative_values(self): - '''Test derivative returns AnalogSignal with correct values''' + """Test derivative returns AnalogSignal with correct values""" derivative1 = elephant.signal_processing.derivative( self.test_signal1) derivative2 = elephant.signal_processing.derivative( @@ -1013,25 +1013,25 @@ def setUp(self): t_stop=self.times[-1] * pq.s, sampling_period=(1 / self.fs) * pq.s) def test_rauc_invalid_signal(self): - '''Test rauc on non-AnalogSignal''' + """Test rauc on non-AnalogSignal""" kwds = {'signal': np.arange(5)} self.assertRaises( ValueError, elephant.signal_processing.rauc, **kwds) def test_rauc_invalid_bin_duration(self): - '''Test rauc on bad bin duration''' + """Test rauc on bad bin duration""" kwds = {'signal': self.test_signal1, 'bin_duration': 'bad'} self.assertRaises( ValueError, elephant.signal_processing.rauc, **kwds) def test_rauc_invalid_baseline(self): - '''Test rauc on bad baseline''' + """Test rauc on bad baseline""" kwds = {'signal': self.test_signal1, 'baseline': 'bad'} self.assertRaises( ValueError, elephant.signal_processing.rauc, **kwds) def test_rauc_units(self): - '''Test rauc returns Quantity or AnalogSignal with correct units''' + """Test rauc returns Quantity or AnalogSignal with correct units""" # test that single-bin result is Quantity with correct units rauc = elephant.signal_processing.rauc( @@ -1050,7 +1050,7 @@ def test_rauc_units(self): self.test_signal1.units * self.test_signal1.times.units) def test_rauc_times_without_overextending_bin(self): - '''Test rauc returns correct times when signal is binned evenly''' + """Test rauc returns correct times when signal is binned evenly""" bin_duration = 1 * pq.s # results in all bin centers < original t_stop rauc_arr = elephant.signal_processing.rauc( @@ -1074,7 +1074,7 @@ def test_rauc_times_without_overextending_bin(self): target_times[-1] + bin_duration) def test_rauc_times_with_overextending_bin(self): - '''Test rauc returns correct times when signal is NOT binned evenly''' + """Test rauc returns correct times when signal is NOT binned evenly""" bin_duration = 0.99 * pq.s # results in one bin center > original t_stop rauc_arr = elephant.signal_processing.rauc( @@ -1098,7 +1098,7 @@ def test_rauc_times_with_overextending_bin(self): target_times[-1] + bin_duration) def test_rauc_values_one_bin(self): - '''Test rauc returns correct values when there is just one bin''' + """Test rauc returns correct values when there is just one bin""" rauc1 = elephant.signal_processing.rauc( self.test_signal1) rauc2 = elephant.signal_processing.rauc( @@ -1117,7 +1117,7 @@ def test_rauc_values_one_bin(self): np.array([6.36517679, 6.36617364])) def test_rauc_values_multi_bin(self): - '''Test rauc returns correct values when there are multiple bins''' + """Test rauc returns correct values when there are multiple bins""" rauc_arr1 = elephant.signal_processing.rauc( self.test_signal1, bin_duration=0.99 * pq.s) rauc_arr2 = elephant.signal_processing.rauc( @@ -1154,7 +1154,7 @@ def test_rauc_values_multi_bin(self): [0.09304862, 0.03039579]])) def test_rauc_mean_baseline(self): - '''Test rauc returns correct values when baseline='mean' is given''' + """Test rauc returns correct values when baseline='mean' is given""" rauc1 = elephant.signal_processing.rauc( self.test_signal1, baseline='mean') rauc2 = elephant.signal_processing.rauc( @@ -1173,7 +1173,7 @@ def test_rauc_mean_baseline(self): np.array([6.36517679, 6.36617364])) def test_rauc_median_baseline(self): - '''Test rauc returns correct values when baseline='median' is given''' + """Test rauc returns correct values when baseline='median' is given""" rauc1 = elephant.signal_processing.rauc( self.test_signal1, baseline='median') rauc2 = elephant.signal_processing.rauc( @@ -1192,7 +1192,7 @@ def test_rauc_median_baseline(self): np.array([6.36517679, 6.36617364])) def test_rauc_arbitrary_baseline(self): - '''Test rauc returns correct values when arbitrary baseline is given''' + """Test rauc returns correct values when arbitrary baseline is given""" rauc1 = elephant.signal_processing.rauc( self.test_signal1, baseline=0.123 * pq.mV) rauc2 = elephant.signal_processing.rauc( @@ -1211,7 +1211,7 @@ def test_rauc_arbitrary_baseline(self): np.array([6.41354725, 6.41429810])) def test_rauc_time_slice(self): - '''Test rauc returns correct values when t_start, t_stop are given''' + """Test rauc returns correct values when t_start, t_stop are given""" rauc1 = elephant.signal_processing.rauc( self.test_signal1, t_start=0.123 * pq.s, t_stop=0.456 * pq.s) rauc2 = elephant.signal_processing.rauc( diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 307f40142..464fec1ba 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -1,7 +1,7 @@ """ Unit tests for the spade module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index d7f1e15bf..d4962834d 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -2,7 +2,7 @@ """ Unit tests for the spectral module. -:copyright: Copyright 2015 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_spike_train_correlation.py b/elephant/test/test_spike_train_correlation.py index 82568d08f..8b30fe505 100644 --- a/elephant/test/test_spike_train_correlation.py +++ b/elephant/test/test_spike_train_correlation.py @@ -2,7 +2,7 @@ """ Unit tests for the spike_train_correlation module. -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -42,9 +42,9 @@ def setUp(self): bin_size=1 * pq.ms) def test_covariance_binned(self): - ''' + """ Test covariance between two binned spike trains. - ''' + """ # Calculate clipped and unclipped res_clipped = sc.covariance( @@ -87,10 +87,10 @@ def test_covariance_binned(self): self.assertAlmostEqual(res_clipped[1][0], target_from_scratch) def test_covariance_binned_same_spiketrains(self): - ''' + """ Test if the covariation between two identical binned spike trains evaluates to the expected 2x2 matrix. - ''' + """ # Calculate correlation binned_st = conv.BinnedSpikeTrain( [self.st_0, self.st_0], t_start=0 * pq.ms, t_stop=50. * pq.ms, @@ -103,10 +103,10 @@ def test_covariance_binned_same_spiketrains(self): assert_array_equal(result[0][0], result[1][1]) def test_covariance_binned_short_input(self): - ''' + """ Test if input list of only one binned spike train yields correct result that matches numpy.cov (covariance with itself) - ''' + """ # Calculate correlation binned_st = conv.BinnedSpikeTrain( self.st_0, t_start=0 * pq.ms, t_stop=50. * pq.ms, @@ -157,9 +157,9 @@ def setUp(self): bin_size=1 * pq.ms) def test_corrcoef_binned(self): - ''' + """ Test the correlation coefficient between two binned spike trains. - ''' + """ # Calculate clipped and unclipped res_clipped = sc.correlation_coefficient( @@ -208,10 +208,10 @@ def test_corrcoef_binned(self): self.assertAlmostEqual(res_clipped[1][0], target_from_scratch) def test_corrcoef_binned_same_spiketrains(self): - ''' + """ Test if the correlation coefficient between two identical binned spike trains evaluates to a 2x2 matrix of ones. - ''' + """ # Calculate correlation binned_st = conv.BinnedSpikeTrain( [self.st_0, self.st_0], t_start=0 * pq.ms, t_stop=50. * pq.ms, @@ -228,9 +228,9 @@ def test_corrcoef_binned_same_spiketrains(self): binned_st, fast=True)) def test_corrcoef_binned_short_input(self): - ''' + """ Test if input list of one binned spike train yields 1.0. - ''' + """ # Calculate correlation binned_st = conv.BinnedSpikeTrain( self.st_0, t_start=0 * pq.ms, t_stop=50. * pq.ms, @@ -246,10 +246,10 @@ def test_corrcoef_binned_short_input(self): binned_st, fast=True)) def test_empty_spike_train(self): - ''' + """ Test whether a warning is yielded in case of empty spike train. Also check correctness of the output array. - ''' + """ # st_2 is empty binned_12 = conv.BinnedSpikeTrain([self.st_1, self.st_2], bin_size=1 * pq.ms) @@ -314,10 +314,10 @@ def setUp(self): bin_size=1 * pq.ms) def test_cross_correlation_histogram(self): - ''' + """ Test generic result of a cross-correlation histogram between two binned spike trains. - ''' + """ # Calculate CCH using Elephant (normal and binary version) with # mode equal to 'full' (whole spike trains are correlated) cch_clipped, bin_ids_clipped = sc.cross_correlation_histogram( @@ -479,8 +479,8 @@ def test_cross_correlation_histogram(self): self.binned_st2, window='dsaij', method='memory') def test_raising_error_wrong_inputs(self): - '''Check that an exception is thrown if the two spike trains are not - fullfilling the requirement of the function''' + """Check that an exception is thrown if the two spike trains are not + fullfilling the requirement of the function""" # Check the bin_sizes are the same self.assertRaises( ValueError, @@ -495,7 +495,7 @@ def test_raising_error_wrong_inputs(self): self.binned_st2, self.st_check_dimension) def test_window(self): - '''Test if the window parameter is correctly interpreted.''' + """Test if the window parameter is correctly interpreted.""" cch_win, bin_ids = sc.cch( self.binned_st1, self.binned_st2, window=[-30, 30]) cch_win_mem, bin_ids_mem = sc.cch( @@ -551,8 +551,8 @@ def test_window(self): self.binned_st2, window='test') def test_border_correction(self): - '''Test if the border correction for bins at the edges is correctly - performed''' + """Test if the border correction for bins at the edges is correctly + performed""" # check that nothing changes for valid lags cch_valid, _ = sc.cross_correlation_histogram( @@ -592,8 +592,8 @@ def test_border_correction(self): / (min_n_bins - n_bins_outside_window))[mask]) def test_kernel(self): - '''Test if the smoothing kernel is correctly defined, and wheter it is - applied properly.''' + """Test if the smoothing kernel is correctly defined, and wheter it is + applied properly.""" smoothed_cch, _ = sc.cross_correlation_histogram( self.binned_st1, self.binned_st2, kernel=np.ones(3)) smoothed_cch_mem, _ = sc.cross_correlation_histogram( @@ -616,9 +616,9 @@ def test_kernel(self): kernel=np.ones(100), method='memory') def test_exist_alias(self): - ''' + """ Test if alias cch still exists. - ''' + """ self.assertEqual(sc.cross_correlation_histogram, sc.cch) def test_annotations(self): @@ -768,7 +768,7 @@ def test_exist_alias(self): class SpikeTrainTimescaleTestCase(unittest.TestCase): def test_timescale_calculation(self): - ''' + """ Test the timescale generation using an alpha-shaped ISI distribution, see [1, eq. 1.68]. This is equivalent to a homogeneous gamma process with alpha=2 and beta=2*nu where nu is the rate. @@ -780,7 +780,7 @@ def test_timescale_calculation(self): [1] Lindner, B. (2009). A brief introduction to some simple stochastic processes. Stochastic Methods in Neuroscience, 1. - ''' + """ nu = 25 / pq.s T = 15 * pq.min bin_size = 1 * pq.ms diff --git a/elephant/test/test_spike_train_dissimilarity.py b/elephant/test/test_spike_train_dissimilarity.py index 9b71d0f03..bb990ba01 100644 --- a/elephant/test/test_spike_train_dissimilarity.py +++ b/elephant/test/test_spike_train_dissimilarity.py @@ -2,7 +2,7 @@ """ Tests for the spike train dissimilarity measures module. -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_spike_train_generation.py b/elephant/test/test_spike_train_generation.py index cca4e5f4d..0a4bb9569 100644 --- a/elephant/test/test_spike_train_generation.py +++ b/elephant/test/test_spike_train_generation.py @@ -2,7 +2,7 @@ """ Unit tests for the spike_train_generation module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -220,10 +220,8 @@ def test_zero_rate(self): for refractory_period in (None, 3 * pq.ms): with warnings.catch_warnings(): warnings.simplefilter("ignore") - """ - Catch RuntimeWarning: divide by zero encountered in true_divide - mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - """ + # RuntimeWarning: divide by zero encountered in true_divide + # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. sp = stgen.homogeneous_poisson_process( rate=0 * pq.Hz, t_stop=10 * pq.s, refractory_period=refractory_period) @@ -488,10 +486,8 @@ def test_zero_rate(self): for refractory_period in (3 * pq.ms, None): with warnings.catch_warnings(): warnings.simplefilter("ignore") - """ - Catch RuntimeWarning: divide by zero encountered in true_divide - mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - """ + # RuntimeWarning: divide by zero encountered in true_divide + # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. spiketrain = stgen.inhomogeneous_poisson_process( self.rate_profile_0, refractory_period=refractory_period) self.assertEqual(spiketrain.size, 0) @@ -793,10 +789,8 @@ def test_cpp_hom_errors(self): # test negative rate with warnings.catch_warnings(): warnings.simplefilter("ignore") - """ - Catches RuntimeWarning: invalid value encountered in sqrt - number = np.ceil(n + 3 * np.sqrt(n)), when `n` == -3 Hz. - """ + # Catches RuntimeWarning: invalid value encountered in sqrt + # number = np.ceil(n + 3 * np.sqrt(n)), when `n` == -3 Hz. self.assertRaises( ValueError, stgen.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, @@ -836,10 +830,8 @@ def test_cpp_het(self): rate = [3, 4] * pq.Hz with warnings.catch_warnings(): warnings.simplefilter("ignore") - """ - Catch RuntimeWarning: divide by zero encountered in true_divide - mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - """ + # Catch RuntimeWarning: divide by zero encountered in true_divide + # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. cpp_het = stgen.cpp(rate, amplitude_distribution, t_stop, t_start=t_start) # testing the ouput formats diff --git a/elephant/test/test_spike_train_surrogates.py b/elephant/test/test_spike_train_surrogates.py index 8487a988d..e8447b070 100644 --- a/elephant/test/test_spike_train_surrogates.py +++ b/elephant/test/test_spike_train_surrogates.py @@ -2,7 +2,7 @@ """ unittests for spike_train_surrogates module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_sta.py b/elephant/test/test_sta.py index 196c0028f..8d04731d5 100644 --- a/elephant/test/test_sta.py +++ b/elephant/test/test_sta.py @@ -2,7 +2,7 @@ """ Tests for the function sta module -:copyright: Copyright 2015-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -48,7 +48,7 @@ def setUp(self): # ************************ Test for typical values ********************** def test_spike_triggered_average_with_n_spikes_on_constant_function(self): - '''Signal should average to the input''' + """Signal should average to the input""" const = 13.8 x = const * np.ones(201) asiga = AnalogSignal( @@ -65,7 +65,7 @@ def test_spike_triggered_average_with_n_spikes_on_constant_function(self): assert_array_almost_equal(STA, cutout, 12) def test_spike_triggered_average_with_shifted_sin_wave(self): - '''Signal should average to zero''' + """Signal should average to zero""" STA = sta.spike_triggered_average( self.asiga0, self.st0, (-4 * ms, 4 * ms)) target = 5e-2 * mV @@ -74,7 +74,7 @@ def test_spike_triggered_average_with_shifted_sin_wave(self): self.assertLess(np.abs(STA).max(), target) def test_only_one_spike(self): - '''The output should be the same as the input''' + """The output should be the same as the input""" x = np.arange(0, 20, 0.1) y = x**2 sr = 10 / ms @@ -108,7 +108,7 @@ def test_usage_of_spikes(self): # ********* an exception or returns an error code *********************** def test_analog_signal_of_wrong_type(self): - '''Analog signal given as list, but must be AnalogSignal''' + """Analog signal given as list, but must be AnalogSignal""" asiga = [0, 1, 2, 3, 4] self.assertRaises(TypeError, sta.spike_triggered_average, asiga, self.st0, (-2 * ms, 2 * ms)) @@ -128,7 +128,7 @@ def test_forgotten_AnalogSignal_argument(self): self.st0, (-2 * ms, 2 * ms)) def test_one_smaller_nrspiketrains_smaller_nranalogsignals(self): - '''Number of spiketrains between 1 and number of analogsignals''' + """Number of spiketrains between 1 and number of analogsignals""" self.assertRaises(ValueError, sta.spike_triggered_average, self.asiga2, self.lst, (-2 * ms, 2 * ms)) @@ -189,7 +189,7 @@ def test_empty_analogsignal(self): asiga, st, (-1 * ms, 1 * ms)) def test_one_spiketrain_empty(self): - '''Test for one empty SpikeTrain, but existing spikes in other''' + """Test for one empty SpikeTrain, but existing spikes in other""" st = [SpikeTrain( [9 * math.pi, 10 * math.pi, 11 * math.pi, 12 * math.pi], units='ms', t_stop=self.asiga1.t_stop), diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index af30a668d..d40ae027c 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -2,7 +2,7 @@ """ Unit tests for the statistics module. -:copyright: Copyright 2014-2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division @@ -387,10 +387,8 @@ def test_lv_raise_error(self): def test_2short_spike_train(self): seq = [1] with self.assertWarns(UserWarning): - """ - Catches UserWarning: Input size is too small. Please provide - an input with more than 1 entry. - """ + # Catches UserWarning: Input size is too small. Please provide + # an input with more than 1 entry. self.assertTrue(math.isnan(statistics.lv(seq, with_nan=True))) diff --git a/elephant/test/test_unitary_event_analysis.py b/elephant/test/test_unitary_event_analysis.py index 9833779d5..b1304fb98 100644 --- a/elephant/test/test_unitary_event_analysis.py +++ b/elephant/test/test_unitary_event_analysis.py @@ -1,7 +1,7 @@ """ Unit tests for the Unitary Events analysis -:copyright: Copyright 2016 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_waveform_features.py b/elephant/test/test_waveform_features.py index 392912e79..aff400afa 100644 --- a/elephant/test/test_waveform_features.py +++ b/elephant/test/test_waveform_features.py @@ -1,7 +1,7 @@ """ Unit tests for the waveform_feature module. -:copyright: Copyright 2014-2019 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/unitary_event_analysis.py b/elephant/unitary_event_analysis.py index 9b6a49c0b..2cf51b747 100644 --- a/elephant/unitary_event_analysis.py +++ b/elephant/unitary_event_analysis.py @@ -37,17 +37,15 @@ ?filepath=doc/tutorials/unitary_event_analysis.ipynb -.. current_module elephant.unitary_event_analysis - Functions overview ------------------ .. autosummary:: - :toctree: toctree/unitary_event_analysis/ + :toctree: _toctree/unitary_event_analysis/ jointJ_window_analysis -:copyright: Copyright 2015-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -352,7 +350,8 @@ def _n_exp_mat_surrogate(mat, pattern_hash, n_surrogates=1): for rz_idx, rz in enumerate(np.arange(n_surrogates)): # row-wise shuffling all elements of zero-one matrix mat_surr = np.copy(mat) - [np.random.shuffle(row) for row in mat_surr] + for row in mat_surr: + np.random.shuffle(row) N_exp_array[rz_idx] = n_emp_mat(mat_surr, pattern_hash)[0][0] return N_exp_array diff --git a/elephant/utils.py b/elephant/utils.py index aefb4d1d2..445b74bc3 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -1,6 +1,6 @@ """ .. autosummary:: - :toctree: toctree/utils + :toctree: _toctree/utils is_time_quantity get_common_start_stop_times @@ -21,6 +21,7 @@ __all__ = [ + "deprecated_alias", "is_binary", "is_time_quantity", "get_common_start_stop_times", @@ -34,7 +35,7 @@ def is_binary(array): """ Parameters ---------- - array: np.ndarray or list + array : np.ndarray or list Returns ------- @@ -52,7 +53,7 @@ def deprecated_alias(**aliases): Parameters ---------- - aliases: str + **aliases The key-value pairs of mapping old --> new argument names of a function. @@ -86,9 +87,9 @@ def _rename_kwargs(func_name, kwargs, aliases): for old, new in aliases.items(): if old in kwargs: if new in kwargs: - raise TypeError("{} received both '{}' and '{}'".format( - func_name, old, new)) - warnings.warn("'{}' is deprecated; use '{}'".format(old, new), + raise TypeError(f"{func_name} received both '{old}' and " + f"'{new}'") + warnings.warn(f"'{old}' is deprecated; use '{new}'", DeprecationWarning) kwargs[new] = kwargs.pop(old) @@ -156,8 +157,8 @@ def get_common_start_stop_times(neo_objects): raise AttributeError("Input neo objects must have 't_start' and " "'t_stop' attributes") if t_stop < t_start: - raise ValueError("t_stop ({t_stop}) is smaller than t_start " - "({t_start})".format(t_stop=t_stop, t_start=t_start)) + raise ValueError(f"t_stop ({t_stop}) is smaller than t_start " + f"({t_start})") return t_start, t_stop @@ -201,8 +202,9 @@ def check_neo_consistency(neo_objects, object_type, t_start=None, tolerance = 0 for neo_obj in neo_objects: if not isinstance(neo_obj, object_type): - raise TypeError("The input must be a list of {}. Got {}".format( - object_type.__name__, type(neo_obj).__name__)) + raise TypeError("The input must be a list of " + f"{object_type.__name__}. Got " + f"{type(neo_obj).__name__}") if neo_obj.units != units: raise ValueError("The input must have the same units.") if t_start is None and abs(neo_obj.t_start.item() - start) > tolerance: @@ -239,7 +241,7 @@ def check_same_units(quantities, object_type=pq.Quantity): raise TypeError(f"The input must be a list of {object_type.__name__}") for quantity in quantities: if not isinstance(quantity, object_type): - raise TypeError(f"The input must be a list of " + raise TypeError("The input must be a list of " f"{object_type.__name__}. Got " f"{type(quantity).__name__}") if quantity.units != units: diff --git a/elephant/waveform_features.py b/elephant/waveform_features.py index 84e32272d..0fa3acd6f 100644 --- a/elephant/waveform_features.py +++ b/elephant/waveform_features.py @@ -1,6 +1,10 @@ # -*- coding: utf-8 -*- """ -Features of waveforms (e.g waveform_snr). +.. autosummary:: + :toctree: _toctree/waveform_features + + waveform_width + waveform_snr :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. @@ -35,7 +39,7 @@ def waveform_width(waveform, cutoff=0.75): cutoff : float, optional Defines the normalized range `[0, cutoff]` of the input sequence for computing the minimum. Must be in `[0, 1)` range. - Default: 0.75. + Default: 0.75 Returns ------- @@ -50,6 +54,12 @@ def waveform_width(waveform, cutoff=0.75): If `cutoff` is not in `[0, 1)` range. + Examples + -------- + >>> from elephant.waveform_features import waveform_width + >>> waveform_width([20, 25, 10, -5, -2, 7, 15], cutoff=0.75) + 3 + """ waveform = np.squeeze(waveform) if np.ndim(waveform) != 1: @@ -70,12 +80,12 @@ def waveform_width(waveform, cutoff=0.75): def waveform_snr(waveforms): """ Return the signal-to-noise ratio of the waveforms of one or more - spike trains. + spike trains :cite:`waveforms-Hatsopoulos2007_5105`. Signal-to-noise ratio is defined as the difference in mean peak-to-trough voltage divided by twice the mean SD. The mean SD is computed by measuring the SD of the spike waveform over all acquired spikes - at each of the sample time points of the waveform and then averaging [1]_. + at each of the sample time points of the waveform and then averaging. Parameters ---------- @@ -88,7 +98,8 @@ def waveform_snr(waveforms): Returns ------- snr : float or np.ndarray - Signal-to-noise ratio according to [1]_. If the input `waveforms` + Signal-to-noise ratio according to + :cite:`waveforms-Hatsopoulos2007_5105`. If the input `waveforms` shape is ``(n_waveforms, time)`` or ``(n_waveforms, 1, time)``, a single float is returned. Otherwise, if the shape is ``(n_waveforms, n_spiketrains, time)``, a numpy array of length @@ -100,16 +111,17 @@ def waveform_snr(waveforms): `spiketrain.waveforms`, if it's loaded from a file, in which case you need to set ``load_waveforms=True`` in ``neo.read_block()``. - References - ---------- - .. [1] Hatsopoulos, N. G., Xu, Q. & Amit, Y. - Encoding of Movement Fragments in the Motor Cortex. - J. Neurosci. 27, 5105–5114 (2007). + Examples + -------- + >>> from elephant.waveform_features import waveform_snr + >>> waveforms = [[20, 25, 10, -5, -2, 7, 15], [17, 29, 11, -4, 0, 5, 20]] + >>> waveform_snr(waveforms) + 12.249999999999998 """ if isinstance(waveforms, neo.SpikeTrain): - warnings.warn("spiketrain input is deprecated; " - "pass 'spiketrain.waveforms' directly.") + warnings.warn("spiketrain input is deprecated; pass " + "'spiketrain.waveforms' directly.", DeprecationWarning) waveforms = waveforms.waveforms # asarray removes quantities, if present waveforms = np.squeeze(np.asarray(waveforms)) diff --git a/readthedocs.yml b/readthedocs.yml index 9a9e63741..15fa6002f 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -8,13 +8,14 @@ sphinx: builder: html configuration: doc/conf.py +conda: + environment: requirements/environment.yml + python: - version: 3.7 install: - method: pip path: . extra_requirements: - docs - extras - - tests - tutorials From 165276fe26174f4747a53ad27b8ca0727a9e4c28 Mon Sep 17 00:00:00 2001 From: Danylo Ulianych Date: Thu, 4 Mar 2021 19:30:01 +0100 Subject: [PATCH 18/63] Release 0.10.0 (#407) --- doc/release_notes.rst | 36 ++++++++++++++++++++++++++++++++++++ elephant/VERSION | 2 +- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/doc/release_notes.rst b/doc/release_notes.rst index 3e279d2e3..8b7cf226a 100644 --- a/doc/release_notes.rst +++ b/doc/release_notes.rst @@ -2,6 +2,42 @@ Release Notes ============= +Elephant 0.10.0 release notes +============================= + +Documentation +------------- +The documentation is revised and restructured by categories (https://github.com/NeuralEnsemble/elephant/pull/386) to simplify navigation on readthedocs and improve user experience. All citations used in Elephant are stored in a single [BibTex file](https://github.com/NeuralEnsemble/elephant/blob/master/doc/bib/elephant.bib). + +Optimizations +------------- + +CUDA and OpenCL support +*********************** +[Analysis of Sequences of Synchronous EvenTs](https://elephant.readthedocs.io/en/latest/reference/asset.html) has become the first module in Elephant that supports CUDA and OpenCL (https://github.com/NeuralEnsemble/elephant/pull/351, https://github.com/NeuralEnsemble/elephant/pull/404, https://github.com/NeuralEnsemble/elephant/pull/399). Whether you have an Nvidia GPU or just run the analysis on a laptop with a built-in Intel graphics card, the speed-up is **X100** and **X1000** compared to a single CPU core. The computations are optimized to a degree that you can analyse and look for spike patterns in real data in several minutes of compute time on a laptop. The installation instructions are described in the [install](https://elephant.readthedocs.io/en/latest/install.html) section. + +Other optimizations +******************* +* Surrogates: sped up bin shuffling (https://github.com/NeuralEnsemble/elephant/pull/400) and reimplemented the continuous time version (https://github.com/NeuralEnsemble/elephant/pull/397) +* Improved memory efficiency of creating a BinnedSpikeTrain (https://github.com/NeuralEnsemble/elephant/pull/395) + +New functionality and features +------------------------------ +* Synchrofact detection (https://github.com/NeuralEnsemble/elephant/pull/322) is a method to detect highly synchronous spikes (at the level of sampling rate precision with an option to extend this to jittered synchrony) and annotate or optionally remove them. +* Added `phase_locking_value`, `mean_phase_vector`, and `phase_difference` functions (https://github.com/NeuralEnsemble/elephant/pull/385/files) +* BinnedSpikeTrain: + - added `to_spike_trains` and `time_slice` functions (https://github.com/NeuralEnsemble/elephant/pull/390). Now you can slice a binned spike train as `bst[:, i:j]` or `bst.time_slice(t_start, t_stop)`. Also, with `to_spike_trains` function, you can generate a realization of spike trains that maps to the same BinnedSpikeTrain object when binned. + - optional CSC format (https://github.com/NeuralEnsemble/elephant/pull/402) + - the `copy` parameter (False by default) in the `binarize` function makes a *shallow* copy, if set to True, of the output BinnedSpikeTrain object (https://github.com/NeuralEnsemble/elephant/pull/402) +* Granger causality tutorial notebook (https://github.com/NeuralEnsemble/elephant/pull/393) +* Unitary Event Analysis support multiple pattern hashes (https://github.com/NeuralEnsemble/elephant/pull/387) + +Bug fixes +--------- +* Account for unidirectional spiketrain->segment links in synchrofact deletion (https://github.com/NeuralEnsemble/elephant/pull/398) +* Joint-ISI dithering: fixed a bug regarding first ISI bin (https://github.com/NeuralEnsemble/elephant/pull/396) +* Fix LvR values from being off when units are in seconds (https://github.com/NeuralEnsemble/elephant/pull/389) + Elephant 0.9.0 release notes **************************** diff --git a/elephant/VERSION b/elephant/VERSION index 899f24fc7..2774f8587 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.9.0 \ No newline at end of file +0.10.0 \ No newline at end of file From c46188475b6dc27a6b6f08d44a9b53f9c8de7ce0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristiano=20K=C3=B6hler?= <42555442+kohlerca@users.noreply.github.com> Date: Thu, 13 May 2021 17:23:58 +0200 Subject: [PATCH 19/63] [Enhancement] Change test framework from Nose to pytest (#413) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Changed to pytest and pytest-cov for running tests with coverage * Changed mpiexec test and added coveralls Co-authored-by: Cristiano Köhler --- .travis.yml | 6 +++--- requirements/requirements-tests.txt | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index bfb85e2ba..2c661a82e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,7 +17,7 @@ matrix: - conda install -c conda-forge pyopencl oclgrind clang=9.0.1 - pip install -r requirements/requirements-extras.txt - pip install mpi4py - script: mpiexec -n 1 python -m mpi4py.futures -m nose --with-coverage --cover-package=elephant + script: mpiexec -n 1 python -m mpi4py.futures -m pytest --cov=elephant after_success: coveralls || echo "coveralls failed" - name: "conda 3.7" @@ -64,11 +64,11 @@ install: - pip -V - pip install -r requirements/requirements-tests.txt - - pip install coverage coveralls + - pip install pytest-cov coveralls - python setup.py install - python -c "from elephant.spade import HAVE_FIM; assert HAVE_FIM" - pip list - python --version script: - nosetests --with-coverage --cover-package=elephant + pytest --cov=elephant diff --git a/requirements/requirements-tests.txt b/requirements/requirements-tests.txt index 26392a26d..55b033e90 100644 --- a/requirements/requirements-tests.txt +++ b/requirements/requirements-tests.txt @@ -1 +1 @@ -nose>=1.3.3 +pytest \ No newline at end of file From d4078632c24494e9d5c3774983e4a540f1255e4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristiano=20K=C3=B6hler?= <42555442+kohlerca@users.noreply.github.com> Date: Fri, 21 May 2021 15:41:43 +0200 Subject: [PATCH 20/63] Changed __repr__ in BinnedSpikeTrain to support quantities<0.12.4 (#418) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristiano Köhler --- elephant/conversion.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index aed60920a..4f5dc5672 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -405,8 +405,8 @@ def num_bins(self): return self.n_bins def __repr__(self): - return f"{type(self).__name__}(t_start={self.t_start}, " \ - f"t_stop={self.t_stop}, bin_size={self.bin_size}; " \ + return f"{type(self).__name__}(t_start={str(self.t_start)}, " \ + f"t_stop={str(self.t_stop)}, bin_size={str(self.bin_size)}; " \ f"shape={self.shape}, " \ f"format={self.sparse_matrix.__class__.__name__})" From 647938190a622c131020fe2fc40fa0dbee44eb42 Mon Sep 17 00:00:00 2001 From: Aitor Morales-Gregorio <43403140+morales-gregorio@users.noreply.github.com> Date: Mon, 7 Jun 2021 08:39:15 +0200 Subject: [PATCH 21/63] [Enhancement] Set complexity dtypes for memory efficiency (#412) * Fix complexity annotation dtype * Adapt test name to new object name * Combine redundant type casts Co-authored-by: kleinjohann --- elephant/statistics.py | 9 +++++---- elephant/test/test_spike_train_synchrony.py | 2 ++ elephant/test/test_statistics.py | 2 +- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 9bfdc154d..170aad6c5 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -1361,11 +1361,12 @@ def _epoch_no_spread(self): 'Note that using the complexity epoch to get ' 'precise spike times can lead to rounding errors.') + complexity = self.time_histogram.magnitude.flatten() + complexity = complexity.astype(np.uint16) + epoch = neo.Epoch(left_edges, durations=durations, - array_annotations={ - 'complexity': - self.time_histogram.magnitude.flatten()}) + array_annotations={'complexity': complexity}) return epoch def _epoch_with_spread(self): @@ -1413,7 +1414,7 @@ def _epoch_with_spread(self): sorting = np.argsort(combined_starts, kind='mergesort') left_edges = bst.bin_edges[combined_starts[sorting]] right_edges = bst.bin_edges[combined_stops[sorting]] - complexities = combined_complexities[sorting].astype(int) + complexities = combined_complexities[sorting].astype(np.uint16) if self.sampling_rate: # ensure that spikes are not on the bin edges diff --git a/elephant/test/test_spike_train_synchrony.py b/elephant/test/test_spike_train_synchrony.py index ea7d67216..08e981163 100644 --- a/elephant/test/test_spike_train_synchrony.py +++ b/elephant/test/test_spike_train_synchrony.py @@ -219,6 +219,8 @@ def _test_template(self, spiketrains, correct_complexities, sampling_rate, for st in spiketrains] assert_array_equal(annotations, correct_complexities) + for a in annotations: + self.assertEqual(a.dtype, np.dtype(np.uint16).type) if mode == 'extract': correct_spike_times = [ diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index d40ae027c..77dce6772 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -919,7 +919,7 @@ def test_annotations(self): self.assertEqual(histogram.annotations['normalization'], output) -class ComplexityPdfTestCase(unittest.TestCase): +class ComplexityTestCase(unittest.TestCase): def test_complexity_pdf_deprecated(self): spiketrain_a = neo.SpikeTrain( [0.5, 0.7, 1.2, 2.3, 4.3, 5.5, 6.7] * pq.s, t_stop=10.0 * pq.s) From 8c388e49f949253e0d66c0754562b30f7c0a7135 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Fri, 13 Aug 2021 08:46:34 +0200 Subject: [PATCH 22/63] Optimized SPADE analysis and SPADE tutorial (#419) * bug fixed dealing with units * fixed same unit error in trial shuffling * added Bielefeld fim.so and adapted filtering and added window param to fpgrowth * removed max_occ test * further unit stuff * debugging for new fim version * enabled multithreading in fpgrowth * less verbose in spade * set equal number of bins in bin shuffling wrt spade * added tolerance to binning in spade everywhere * Added accelerated FIM algorithm sources by Florian Porrmann. * Enh/accelerated spade build (#82) * Added cibuildwheel action * Added Python requirements to wheel build * Build only on 64bit machines, otherwise overflow * Removed Windows for testing, as vc is not available * Removed MacOS for testing, as -fopenmp is not available * Removed pp- (pypy) builds since they lack C. * Fixed removing pp- (pypy) builds since they lack C. * Put Macos back in. * Windows Hack * Remove vcpython alltogether, ignore 2.7 Python * Removed extra compile option, which breaks on Windows * Removed more extra compile options, which breaks on Windows * Try C++ instead of Gnu++. * Try C++ instead of Gnu++ Windows style argument. * Remove linux build while testing windows. * Remove libraries. * Differentiate Windows and Linux. * Added missing import. * Last mile: MacOS * Remove openMP lib * Remove openMP lib * Add openMP lib * More brew installs * Mac is called mac on github * Make sure C is reinstalled. * Multilib * Next try, new options * Ignore warning about void type * Update newsest fim package * Revert "Ignore warning about void type" This reverts commit 3ff6b62c * Revert to prior fim, new compiler argument. * Revert "Update newsest fim package" This reverts commit f321f778 * Definitely, gnu++17, but new try. * Try C++ * Warning message * llvm maybe? * Added apple in source * Small fixes for MacOS, but not comprehensive * Limit to Windows and Linux for now * Remove MacOS entry * Fix fix from mindlessness * Testrun * Trying to include fim.so, despite its renaming by wheels * Added newest version of original module * Reverted previous breaking change commited by accident. * Reverted package name from testing. * Test focal as CI build * Test bionic as CI build * Understand installation issue on CI -- is importing elephant importing the installed version? * Spelling error only * Try to make sure travis loads the installed elephant, not the cwd. * One step further -- which version will nosetests use? * Switch to pytest as of PR #413 * Added authors of new FIM module and reference in new docs. * Added authors of new FIM module and reference in new docs. * Small text clarifications. * Test if entry for fim.so/pyd in MANIFEST is now redundant. * Update elephant/spade.py Co-authored-by: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> * Update elephant/spade.py Co-authored-by: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> * Added SPADE tutorial * Prevent wheel building on every push, and limit scipy version workaround * Pushed tutorial, removed file added in error * New attempt to make mybinder install requirements. * New attempt, dropping viziphant. * Avoid recursive elephant installation by viziphant in postBuild * Removed unit test that is fragile as it depends on the implementation of surrogate methods * Add viziphant to RTD environment * Typo in tutorial * Add viziphant to travis doc tests Co-authored-by: pbouss Co-authored-by: stellalessandra Co-authored-by: Alessandra Stella Co-authored-by: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> --- .github/workflows/build_wheels.yml | 43 + .travis.yml | 11 +- MANIFEST.in | 3 - doc/authors.rst | 3 + doc/tutorials.rst | 7 + doc/tutorials/spade.ipynb | 239 +++++ elephant/spade.py | 54 +- elephant/spade_src/LICENSE | 52 +- elephant/spade_src/include/ClosedDetect.h | 174 ++++ elephant/spade_src/include/ClosedTree.h | 314 ++++++ elephant/spade_src/include/Defines.h | 34 + elephant/spade_src/include/FPGrowth.h | 1072 +++++++++++++++++++++ elephant/spade_src/include/FPNode.h | 100 ++ elephant/spade_src/include/FPTree.h | 202 ++++ elephant/spade_src/include/FrequencyRef.h | 188 ++++ elephant/spade_src/include/HeapAlloc.h | 124 +++ elephant/spade_src/include/Logger.h | 124 +++ elephant/spade_src/include/Memory.h | 207 ++++ elephant/spade_src/include/Pattern.h | 238 +++++ elephant/spade_src/include/SigTerm.h | 98 ++ elephant/spade_src/include/Timer.h | 159 +++ elephant/spade_src/include/Types.h | 57 ++ elephant/spade_src/include/Utils.h | 401 ++++++++ elephant/spade_src/src/fim.cpp | 367 +++++++ elephant/spike_train_surrogates.py | 3 +- elephant/test/test_spade.py | 64 +- postBuild | 5 + readthedocs.yml | 3 + requirements/requirements.txt | 5 +- setup.py | 79 +- 30 files changed, 4310 insertions(+), 120 deletions(-) create mode 100644 .github/workflows/build_wheels.yml create mode 100644 doc/tutorials/spade.ipynb create mode 100644 elephant/spade_src/include/ClosedDetect.h create mode 100644 elephant/spade_src/include/ClosedTree.h create mode 100644 elephant/spade_src/include/Defines.h create mode 100644 elephant/spade_src/include/FPGrowth.h create mode 100644 elephant/spade_src/include/FPNode.h create mode 100644 elephant/spade_src/include/FPTree.h create mode 100644 elephant/spade_src/include/FrequencyRef.h create mode 100644 elephant/spade_src/include/HeapAlloc.h create mode 100644 elephant/spade_src/include/Logger.h create mode 100644 elephant/spade_src/include/Memory.h create mode 100644 elephant/spade_src/include/Pattern.h create mode 100644 elephant/spade_src/include/SigTerm.h create mode 100644 elephant/spade_src/include/Timer.h create mode 100644 elephant/spade_src/include/Types.h create mode 100644 elephant/spade_src/include/Utils.h create mode 100644 elephant/spade_src/src/fim.cpp diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml new file mode 100644 index 000000000..46cd527d8 --- /dev/null +++ b/.github/workflows/build_wheels.yml @@ -0,0 +1,43 @@ +name: Build Wheels + +# Trigger the workflow on push or pull request of the master +on: + push: + branches: + - master + pull_request: + branches: + - master + +# Building wheels on Ubuntu and Windows systems +jobs: + build_wheels: + name: Build wheels on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-20.04, windows-2019] + + steps: + - uses: actions/checkout@v2 + + # Used to host cibuildwheel + - uses: actions/setup-python@v2 + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==1.10.0 + + - name: Install libomp + if: runner.os == 'macOS' + run: brew install libomp + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + env: + CIBW_SKIP: "cp27-* cp33-* cp34-* cp35-* pp*" + CIBW_PROJECT_REQUIRES_PYTHON: ">=3.6" + CIBW_ARCHS: "auto64" + + - uses: actions/upload-artifact@v2 + with: + path: ./wheelhouse/*.whl diff --git a/.travis.yml b/.travis.yml index 2c661a82e..bae6dd21f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,4 @@ -dist: xenial +dist: bionic language: python sudo: false @@ -6,7 +6,6 @@ addons: apt: update: true - matrix: include: - name: "conda 3.6 extras,opencl" @@ -17,7 +16,7 @@ matrix: - conda install -c conda-forge pyopencl oclgrind clang=9.0.1 - pip install -r requirements/requirements-extras.txt - pip install mpi4py - script: mpiexec -n 1 python -m mpi4py.futures -m pytest --cov=elephant + script: mpiexec -n 1 python -m mpi4py.futures -m pytest --cov=elephant --import-mode=importlib after_success: coveralls || echo "coveralls failed" - name: "conda 3.7" @@ -42,6 +41,7 @@ matrix: - pip install -r requirements/requirements-tutorials.txt - pip install -r requirements/requirements-extras.txt - pip install mpi4py + - pip install viziphant # remove viziphant, once integrated into requirements-tutorials.txt - sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py script: cd doc && make html @@ -66,9 +66,10 @@ install: - pip install -r requirements/requirements-tests.txt - pip install pytest-cov coveralls - python setup.py install - - python -c "from elephant.spade import HAVE_FIM; assert HAVE_FIM" + - python -c "import sys; sys.path.remove(''); import elephant; print(elephant.__file__)" + - python -c "import sys; sys.path.remove(''); from elephant.spade import HAVE_FIM; assert HAVE_FIM" - pip list - python --version script: - pytest --cov=elephant + pytest --cov=elephant --import-mode=importlib diff --git a/MANIFEST.in b/MANIFEST.in index 6d901d47b..22f076658 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -7,8 +7,6 @@ include elephant/VERSION include elephant/current_source_density_src/README.md include elephant/current_source_density_src/test_data.mat include elephant/spade_src/LICENSE -recursive-include elephant/spade_src *.so *.pyd -include elephant/asset/* include elephant/test/spike_extraction_test_data.txt recursive-include doc * prune doc/_build @@ -16,5 +14,4 @@ prune doc/tutorials/.ipynb_checkpoints prune doc/reference/toctree include doc/reference/toctree/kernels/* recursive-exclude * *.h5 -recursive-exclude * *.nix recursive-exclude * *~ diff --git a/doc/authors.rst b/doc/authors.rst index a811998ad..d36ec722b 100644 --- a/doc/authors.rst +++ b/doc/authors.rst @@ -47,6 +47,8 @@ contribution, and may not be the current affiliation of a contributor. * Philipp Steigerwald [12] * Manuel Ciba [12] * Maximilian Kramer [1] +* Florian Porrmann [13] +* Sarah Pilz [13] 1. Institute of Neuroscience and Medicine (INM-6), Computational and Systems Neuroscience & Institute for Advanced Simulation (IAS-6), Theoretical Neuroscience, Jülich Research Centre and JARA, Jülich, Germany 2. Unité de Neurosciences, Information et Complexité, CNRS UPR 3293, Gif-sur-Yvette, France @@ -60,5 +62,6 @@ contribution, and may not be the current affiliation of a contributor. 10. Instituto de Neurobiología, Universidad Nacional Autónoma de México, Mexico City, Mexico 11. Case Western Reserve University (CWRU), Cleveland, OH, USA 12. BioMEMS Lab, TH Aschaffenburg University of applied sciences, Germany +13. Cognitronics and Sensor Systems, CITEC, Bielefeld University, Bielefeld, Germany If we've somehow missed you off the list we're very sorry - please let us know. diff --git a/doc/tutorials.rst b/doc/tutorials.rst index ff7bef263..18e907f10 100644 --- a/doc/tutorials.rst +++ b/doc/tutorials.rst @@ -47,6 +47,13 @@ Advanced .. image:: https://mybinder.org/badge.svg :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master?filepath=doc/tutorials/gpfa.ipynb +* Spike Pattern Detection and Evaluation (SPADE) + + :doc:`View the notebook <../tutorials/spade>` or run interactively: + + .. image:: https://mybinder.org/badge.svg + :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master?filepath=doc/tutorials/spade.ipynb + * Analysis of Sequences of Synchronous EvenTs (ASSET) :doc:`View the notebook <../tutorials/asset>` or run interactively: diff --git a/doc/tutorials/spade.ipynb b/doc/tutorials/spade.ipynb new file mode 100644 index 000000000..c86a46081 --- /dev/null +++ b/doc/tutorials/spade.ipynb @@ -0,0 +1,239 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SPADE Tutorial" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-23T08:16:59.289299Z", + "start_time": "2020-04-23T08:16:58.185541Z" + } + }, + "outputs": [], + "source": [ + "import quantities as pq\n", + "import neo\n", + "import elephant\n", + "import viziphant\n", + "import random\n", + "random.seed(4542)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate correlated data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "SPADE is a method to detect repeated spatio-temporal activity patterns in parallel spike train data that occur in excess to chance expectation. In this tutorial, we will use SPADE to detect the simplest type of such patterns, synchronous events that are found across a subset of the neurons considered (i.e., patterns that do not exhibit a *temporal extent*). We will demonstrate the method on stochastic data in which we control the patterns statistics. In a first step, let use generate 10 random spike trains, each modeled after a Poisson statistics, in which a certain proportion of the spikes is synchronized across the spike trains. To this end, we use the `compound_poisson_process()` function, which expects the rate of the resulting processes in addition to a distribution `A[n]` indicating the likelihood of finding synchronous spikes of a given order `n`. In our example, we construct the distribution such that we have a small probability to produce a synchronous event of order 10 (`A[10]==0.02`). Otherwise spikes are not synchronous with those of other neurons (i.e., synchronous events of order 1, `A[1]==0.98`). Notice that the length of the distribution `A` determines the number `len(A)-1` of spiketrains returned by the function, and that `A[0]` is ignored for reasons of clearer notation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-23T08:16:59.454207Z", + "start_time": "2020-04-23T08:16:59.419213Z" + } + }, + "outputs": [], + "source": [ + "spiketrains = elephant.spike_train_generation.compound_poisson_process(\n", + " rate=5*pq.Hz, A=[0]+[0.98]+[0]*8+[0.02], t_stop=10*pq.s)\n", + "len(spiketrains)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In a second step, we add 90 purely random Poisson spike trains using the `homogeneous_poisson_process()|` function, such that in total we have 10 spiketrains that exhibit occasional synchronized events, and 90 uncorrelated spike trains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(90):\n", + " spiketrains.append(elephant.spike_train_generation.homogeneous_poisson_process(\n", + " rate=5*pq.Hz, t_stop=10*pq.s))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mining patterns with SPADE" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-23T08:17:01.595733Z", + "start_time": "2020-04-23T08:17:01.591410Z" + } + }, + "source": [ + "In the next step, we run the `spade()` method to extract the synchronous patterns. We choose 1 ms as the time scale for discretization of the patterns, and specify a window length of 1 bin (meaning, we search for synchronous patterns only). Also, we concentrate on patterns that involve at least 3 spikes, therefore significantly accelerating the search by ignoring frequent events of order 2. To test for the significance of patterns, we set to repeat the pattern detection on 100 spike dither surrogates of the original data, creating by dithing spike up to 5 ms in time. For the final step of pattern set reduction (psr), we use the standard parameter set `[0, 0, 0]`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-23T08:17:03.218505Z", + "start_time": "2020-04-23T08:17:02.387311Z" + } + }, + "outputs": [], + "source": [ + "patterns = elephant.spade.spade(\n", + " spiketrains=spiketrains, binsize=1*pq.ms, winlen=1, min_spikes=3, \n", + " n_surr=100,dither=5*pq.ms, \n", + " psr_param=[0,0,0],\n", + " output_format='patterns')['patterns']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The output `patterns` of the method contains information on the found patterns. In this case, we retrieve the pattern we put into the data: a pattern involving the first 10 neurons (IDs 0 to 9), occuring 4 times." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "patterns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we visualize the found patterns using the function `plot_patterns()` of the viziphant library. Marked in red are the patterns of order ten injected into the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-23T08:17:04.600606Z", + "start_time": "2020-04-23T08:17:04.423012Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "viziphant.spade.plot_patterns(spiketrains, patterns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/elephant/spade.py b/elephant/spade.py index a639a1976..34ecf51de 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -25,13 +25,15 @@ Notes ----- -This modules relies on the implementation of the fp-growth algorithm contained -in the file fim.so which can be found here (http://www.borgelt.net/pyfim.html) -and should be available in the spade_src folder (elephant/spade_src/). -If the fim.so module is not present in the correct location or cannot be -imported (only available for linux OS) SPADE will make use of a python -implementation of the fast fca algorithm contained in -`elephant/spade_src/fast_fca.py`, which is about 10 times slower. +This modules relies on the C++ implementation of the fp-growth algorithm developed by +Forian Porrmann (available at https://github.com/fporrmann/FPG). The module replaces +a more generic implementation of the algorithm by Christian Borgelt +(http://www.borgelt.net/pyfim.html) that was used in previous versions of Elephant. +If the module (fim.so) is not available in a precompiled format (currently Linux/Windows) or cannot +be compiled on a given system during install, SPADE will make use of a pure Python implementation +of the fast fca algorithm contained in `elephant/spade_src/fast_fca.py`, which is +significantly slower. + See Also -------- @@ -82,7 +84,7 @@ Refer to Viziphant documentation to check how to visualzie such patterns. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2021 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals @@ -881,13 +883,16 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, zmin=min_z, zmax=max_z, report='a', - algo='s') + algo='s', + winlen=winlen, + threads=0, + verbose=4) break else: fpgrowth_output = [(tuple(transactions[0]), len(transactions))] # Applying min/max conditions and computing extent (window positions) - fpgrowth_output = [concept for concept in fpgrowth_output - if _fpgrowth_filter(concept, winlen, max_c, min_neu)] + # fpgrowth_output = [concept for concept in fpgrowth_output + # if _fpgrowth_filter(concept, winlen, max_c, min_neu)] # filter out subsets of patterns that are found as a side-effect # of using the moving window strategy fpgrowth_output = _filter_for_moving_window_subsets( @@ -935,18 +940,18 @@ def _fpgrowth(transactions, min_c=2, min_z=2, max_z=None, return spectrum -def _fpgrowth_filter(concept, winlen, max_c, min_neu): - """ - Filter for selecting closed frequent items set with a minimum number of - neurons and a maximum number of occurrences and first spike in the first - bin position - """ - intent = np.array(concept[0]) - keep_concept = (min(intent % winlen) == 0 - and concept[1] <= max_c - and np.unique(intent // winlen).shape[0] >= min_neu - ) - return keep_concept +# def _fpgrowth_filter(concept, winlen, max_c, min_neu): +# """ +# Filter for selecting closed frequent items set with a minimum number of +# neurons and a maximum number of occurrences and first spike in the first +# bin position +# """ +# intent = np.array(concept[0]) +# keep_concept = (min(intent % winlen) == 0 +# and concept[1] <= max_c +# and np.unique(intent // winlen).shape[0] >= min_neu +# ) +# return keep_concept def _rereference_to_last_spike(transactions, winlen): @@ -1362,7 +1367,8 @@ def _generate_binned_surrogates( binned_surrogates, bin_size=bin_size, t_start=spiketrains[0].t_start, - t_stop=spiketrains[0].t_stop) + t_stop=spiketrains[0].t_stop, + tolerance=None) elif surr_method in ('joint_isi_dithering', 'isi_dithering'): surrs = [instance.dithering()[0] for instance in joint_isi_instances] diff --git a/elephant/spade_src/LICENSE b/elephant/spade_src/LICENSE index 042bd372a..8399eb48a 100644 --- a/elephant/spade_src/LICENSE +++ b/elephant/spade_src/LICENSE @@ -1,11 +1,53 @@ +This directory contains the fim module used by the elephant.spade module. +The code is originally published at https://github.com/fporrmann/FPG + +MIT License + +Copyright (c) 2020-2021 Florian Porrmann + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + + +The version of fim used by earlier versions of elephant.spade was written by Christian Borgelt (https://borgelt.net/software.html). + For any version published on or after October 23, 2014: -(MIT license, or more precisely Expat License; to be found in the file mit-license.txt in the directory /doc in the source package of the program, see also opensource.org and wikipedia.org) +MIT license + +Copyright (c) 1996-2014 Christian Borgelt -© 1996-2014 Christian Borgelt +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/elephant/spade_src/include/ClosedDetect.h b/elephant/spade_src/include/ClosedDetect.h new file mode 100644 index 000000000..fc3d478d5 --- /dev/null +++ b/elephant/spade_src/include/ClosedDetect.h @@ -0,0 +1,174 @@ +/* + * File: ClosedDetect.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + + +#include "Defines.h" +#include "Logger.h" +#include "Types.h" +#include "ClosedTree.h" + +#include + +class ClosedDetect +{ + DISABLE_COPY_ASSIGN_MOVE(ClosedDetect) + +public: + ClosedDetect(const std::size_t& size) : + m_size(size), + m_cnt(0), + m_pTrees(nullptr) + { + m_pTrees = new ClosedTree[size + 1]; + m_pTrees[0].Init(); + m_pTrees[0].Add(nullptr, 0, 0); + m_pTrees[0].SetItem(ITEM_MAX - 1); + } + + ~ClosedDetect() + { + delete[] m_pTrees; + } + + int Add(ItemID item, Support supp) + { + UNUSED(item); + UNUSED(supp); +#ifndef ALL_PATTERN +#ifdef DEBUG + LOG_DEBUG << "CD_ADD: item=" << item << "; supp=" << supp << std::flush; +#endif + ClosedTree* t = m_pTrees + m_cnt; + + if (!t || !(t->Valid())) + { + ClosedTree* prev = m_pTrees + (m_cnt - 1); + t = prev->Project(t); + if (!t) return -1; + } + + t->Prune(item); +#ifdef DEBUG + LOG_DEBUG << " max=" << t->GetMax() << std::flush; +#endif + if (t->GetMax() >= supp) + { +#ifdef DEBUG + LOG_DEBUG << " Exit" << std::endl; +#endif + return 0; + } + ++m_cnt; +#ifdef DEBUG + LOG_DEBUG << std::endl; +#endif +#endif + return 1; + } + + int Add2(ItemID item, Support supp) + { + UNUSED(item); + UNUSED(supp); +#ifdef DEBUG + LOG_DEBUG << "CD_ADD: item=" << item << "; supp=" << supp << std::flush; +#endif + ClosedTree* t = m_pTrees + m_cnt; + + if (!t || !(t->Valid())) + { + ClosedTree* prev = m_pTrees + (m_cnt - 1); + t = prev->Project(t); + if (!t) return -1; + } + + t->Prune(item); +#ifdef DEBUG + LOG_DEBUG << " max=" << t->GetMax() << std::flush; +#endif + if (t->GetMax() >= supp) + { +#ifdef DEBUG + LOG_DEBUG << " Exit" << std::endl; +#endif + return 0; + } + ++m_cnt; +#ifdef DEBUG + LOG_DEBUG << std::endl; +#endif + return 1; + } + + int Update(ItemID* items, int32_t n, const Support& supp) + { + for (size_t i = 0; i < m_cnt; i++) + { + ClosedTree* t = &m_pTrees[i]; + while (*items != t->GetItem()) + { + ++items; + --n; + } + + t->Add(++items, --n, supp); + } + return 0; + } + + + void Remove(std::size_t n) + { +#ifdef DEBUG + LOG_DEBUG << "remove" << std::flush; +#endif + for (n = (n < m_cnt) ? m_cnt - n : 0; m_cnt > n; m_cnt--) + { + if (m_pTrees[m_cnt].Valid()) + { +#ifdef DEBUG + LOG_DEBUG << " item=" << m_pTrees[m_cnt].GetItem() << std::flush; +#endif + m_pTrees[m_cnt].Clear(); + } + } +#ifdef DEBUG + LOG_DEBUG << std::endl; +#endif + } + + Support GetSupport() const + { + return (m_cnt > 0) ? m_pTrees[m_cnt - 1].GetMax() : m_pTrees[0].GetSupport(); + } + +private: + std::size_t m_size; + std::size_t m_cnt; + ClosedTree* m_pTrees; +}; diff --git a/elephant/spade_src/include/ClosedTree.h b/elephant/spade_src/include/ClosedTree.h new file mode 100644 index 000000000..ea261c03c --- /dev/null +++ b/elephant/spade_src/include/ClosedTree.h @@ -0,0 +1,314 @@ +/* + * File: ClosedTree.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +/* + * The following implementation is in large parts, based on the closed item set + * filter implemented by Christian Borgelt (https://borgelt.net/fpgrowth.html) + */ + +#pragma once + +#include "Memory.h" +#include "Types.h" +#include "Utils.h" + +struct ClosedNode +{ + ItemID item; + Support supp; + ClosedNode* sibling; + ClosedNode* children; + + void SetFreeNode(ClosedNode* pNode) + { + sibling = pNode; + } + + ClosedNode* GetFreeNode() const + { + return sibling; + } +}; + +using CNMemory = Memory; + +class ClosedTree +{ + DISABLE_COPY_ASSIGN_MOVE(ClosedTree) + +public: + ClosedTree() : + m_pMem(nullptr), + m_item(ITEM_MAX), + m_max(0), + m_root() + { + } + + ~ClosedTree() + { + delete m_pMem; + } + + void Init() + { + if (m_pMem == nullptr) m_pMem = new CNMemory(4095); + m_item = ITEM_MAX; + m_max = 0; + m_root.sibling = m_root.children = nullptr; + m_root.item = ITEM_MAX; + m_root.supp = 0; + } + + bool Valid() const + { + return m_item < ITEM_MAX; + } + + void Add(ItemID* pItems, int32_t n, Support supp) + { + ItemID i; + ClosedNode** p; + ClosedNode* pNode; + + if (supp > m_max) m_max = supp; + + pNode = &m_root; + + do + { + if (supp > pNode->supp) pNode->supp = supp; + if (--n < 0) return; + + i = *pItems++; + p = &pNode->children; + while (*p && ((*p)->item > i)) p = &(*p)->sibling; + pNode = *p; + } while (pNode && (pNode->item == i)); + + pNode = m_pMem->Alloc(); + pNode->supp = supp; + pNode->item = i; + pNode->sibling = *p; + *p = pNode; + + while (--n >= 0) + { + pNode = pNode->children = m_pMem->Alloc(); + pNode->supp = supp; + pNode->item = *pItems++; + pNode->sibling = nullptr; + } + + pNode->children = nullptr; + } + + ClosedTree* Project(ClosedTree* pDst) + { + ClosedNode* p; + + pDst->Init(); + + pDst->SetItem(ITEM_MAX - 1); + pDst->SetMax(0); + m_max = 0; + pDst->GetRoot().supp = 0; + + p = &m_root; + + if (!p->children) return pDst; + p = p->children = prune(p->children, m_item); + + if (!p || (p->item != m_item)) return pDst; + + pDst->GetRoot().supp = p->supp; + m_max = p->supp; + + if (p->children) + pDst->GetRoot().children = p = pDst->copy(p->children); + + p = &m_root; + p->children = prune(p->children, m_item + 1); + + return pDst; + } + + void Prune(const ItemID& item) + { + ClosedNode* p; + + m_item = item; + p = &m_root; + p = p->children = prune(p->children, item); + m_max = (p && (p->item == item)) ? p->supp : 0; + } + + void Clear() + { + m_pMem->Clear(); + m_max = 0; + m_item = ITEM_MAX; + m_root.sibling = nullptr; + m_root.children = nullptr; + m_root.supp = 0; + } + + const ItemID& GetItem() const + { + return m_item; + } + + const Support& GetMax() const + { + return m_max; + } + + const Support& GetSupport() const + { + return m_root.supp; + } + + ClosedNode& GetRoot() + { + return m_root; + } + + CNMemory* GetMem() + { + return m_pMem; + } + + void SetItem(const ItemID& item) + { + m_item = item; + } + + void SetMax(const Support& max) + { + m_max = max; + } + +private: + ClosedNode* merge(ClosedNode* s1, ClosedNode* s2) + { + ClosedNode* pOut; + ClosedNode** ppEnd; + ClosedNode* p; + + if (!s1) return s2; + if (!s2) return s1; + ppEnd = &pOut; + + while (1) + { + if (s1->item > s2->item) + { + *ppEnd = s1; + ppEnd = &s1->sibling; + s1 = *ppEnd; + if (!s1) break; + } + else if (s2->item > s1->item) + { + *ppEnd = s2; + ppEnd = &s2->sibling; + s2 = *ppEnd; + if (!s2) break; + } + else + { + s1->children = merge(s1->children, s2->children); + if (s1->supp < s2->supp) + s1->supp = s2->supp; + + p = s2; + s2 = s2->sibling; + m_pMem->Free(p); + + *ppEnd = s1; + ppEnd = &s1->sibling; + s1 = *ppEnd; + if (!s1 || !s2) break; + } + } + + *ppEnd = (s1) ? s1 : s2; + return pOut; + } + + ClosedNode* prune(ClosedNode* node, const ItemID& item) + { + ClosedNode *p, *b = NULL; + + while (node && (node->item > item)) + { + node->children = p = prune(node->children, item); + if (p) b = (!b) ? p : merge(b, p); + p = node; + node = node->sibling; + m_pMem->Free(p); + } + + return (!node) ? b : (!b) ? node + : merge(b, node); + } + + ClosedNode* copy(const ClosedNode* pSrc) + { + ClosedNode* pDst; + ClosedNode* pNode; + ClosedNode** ppEnd = &pDst; + ClosedNode* pC; + + do + { + *ppEnd = pNode = m_pMem->Alloc(); + if (!pNode) return nullptr; + + pNode->item = pSrc->item; + pNode->supp = pSrc->supp; + pC = pSrc->children; + if (pC) + { + pC = copy(pC); + if (!pC) return nullptr; + } + + pNode->children = pC; + ppEnd = &pNode->sibling; + pSrc = pSrc->sibling; + } while (pSrc); + + *ppEnd = nullptr; + return pDst; + } + +private: + CNMemory* m_pMem; + ItemID m_item; + Support m_max; + ClosedNode m_root; +}; diff --git a/elephant/spade_src/include/Defines.h b/elephant/spade_src/include/Defines.h new file mode 100644 index 000000000..988048b2c --- /dev/null +++ b/elephant/spade_src/include/Defines.h @@ -0,0 +1,34 @@ +/* + * File: Defines.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#define ALL_PATTERN +//#define PERF_EXT_EXPANSION + +//#define MEMORY_VERBOSE + +// #define USE_OPENMP diff --git a/elephant/spade_src/include/FPGrowth.h b/elephant/spade_src/include/FPGrowth.h new file mode 100644 index 000000000..f9f89a314 --- /dev/null +++ b/elephant/spade_src/include/FPGrowth.h @@ -0,0 +1,1072 @@ +/* + * File: FPGrowth.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef USE_OPENMP +#include +#endif + +#ifdef USE_MPI +#include +#endif + +#include + +#include "Defines.h" +#include "FPNode.h" +#include "Logger.h" +#include "Memory.h" +#include "SigTerm.h" +#include "Timer.h" +#include "Types.h" +#include "Utils.h" + +#include "ClosedDetect.h" +#include "FPTree.h" +#include "FrequencyRef.h" +#include "Pattern.h" +DEFINE_EXCEPTION(FPGException) + +class FPGrowth +{ + DISABLE_COPY_ASSIGN_MOVE(FPGrowth) +public: + // Threads = 0 - Use maximal available amount of threads + // Threads = -1 or 1 disable multithreading, only use 1 thread + // Threads = x <= MAX_THREADS - Use x threads + // Threads = x > MAX_THREADS - Use MAX_THREADS threads + FPGrowth(Transactions& transactions, const Support minSupport = 1, const uint32_t minPatternLen = 1, const uint32_t maxPatternLen = 0, const ItemC winLen = 20, const uint32_t maxc = -1, const uint32_t minneu = 1, const int32_t threads = 0) : + m_minSupport(minSupport), + m_minPatternLen(minPatternLen), + m_maxPatternLen(maxPatternLen), + m_winLen(winLen), + m_maxSupport(maxc), + m_minNeuronCount(minneu), + m_tree(nullptr), + m_maxItemCnt(0), + m_objs(1), + m_pDataObjs(nullptr), + m_pIdx2Id(nullptr), + m_pId2Item(nullptr), + m_memory(65536), + m_pThreadMem(nullptr), + m_pPattern(nullptr), + m_pClosedDetect(nullptr), + m_initTime() + { +#ifdef ALL_PATTERN +#ifdef PERF_EXT_EXPANSION + std::string mode = "All Frequent Itemsets with Perfect Extension Expansion"; +#else + std::string mode = "All Frequent Itemsets without Perfect Extension Expansion"; +#endif +#else + std::string mode = "Closed Itemsets"; +#endif +#ifdef USE_MPI + mode += " - with MPI"; +#endif + LOG_INFO << " ===== FP-Growth (" << mode << ") =====" << std::endl; + + DataBase db; + FrequencyMap frequency; + Timer timerSub; + + m_initTime.Start(); + + frequency = getFrequency(transactions); + + LOG_INFO << "Items: " << frequency.size() << std::endl; + LOG_INFO << "Transactions: " << transactions.size() << std::endl; + + LOG_VERBOSE << "Reducing and sorting transactions ... " << std::flush; + timerSub.Start(); + + do + { + reduceTransactions(transactions); + frequency = getFrequency(transactions); + } while (reduceItems(transactions, frequency)); + + for (const Transaction& trans : transactions) + { + TransactionC tC; + for (const ItemC& item : trans) + tC.push_back(item); + + db.push_back(tC); + } + + timerSub.Stop(); + LOG_VERBOSE << "Done after: " << timerSub << std::endl; + LOG_VERBOSE << "Items: " << frequency.size() << std::endl; + LOG_VERBOSE << "Transactions: " << transactions.size() << std::endl; + + timerSub.Start(); + m_maxItemCnt = frequency.size(); + +#ifdef USE_OPENMP + int32_t maxThreads = omp_get_num_threads(); + if ((threads <= maxThreads && threads > 1)) + { + LOG_INFO << "Limiting the number of threads to " << threads << std::endl; + omp_set_num_threads(threads); + } + else if (threads == 1 || threads == -1) + { + LOG_INFO << "Multi-threading disabled" << std::endl; + omp_set_num_threads(1); + } + else if (threads > maxThreads) + LOG_WARNING << "Set number of threads (" << threads << ") exceeds the maximal available number of threads (" << maxThreads << "), limiting to maximal number" << std::endl; + + m_objs = omp_get_max_threads(); + if (threads == 0 || threads > 1) + LOG_INFO << "Number of Threads: " << m_objs << std::endl; +#else + UNUSED(threads); +#endif + + m_pDataObjs = new DataObjs[m_objs](); + m_pThreadMem = new FPNMemory[m_objs]; + + for (int32_t i = 0; i < m_objs; i++) + { + m_pDataObjs[i].Init(m_maxItemCnt); + m_pThreadMem[i].Init(65536); + } + + m_pPattern = new Pattern[m_maxItemCnt]; + + m_pIdx2Id = new uint32_t[m_maxItemCnt](); + m_pId2Item = new ItemC[m_maxItemCnt](); + + m_pClosedDetect = new ClosedDetect(m_maxItemCnt); + + timerSub.Stop(); + LOG_VERBOSE << "Memory Allocation done after: " << timerSub << std::endl; + + FrequencyMapC F; + + for (TransactionC& transaction : db) + { + for (ItemRef& itemRef : transaction) + { + F.try_emplace(itemRef.item, std::make_shared(F.size())); + F[itemRef.item]->Inc(&itemRef); + } + } + + // This is currently required to be a RefPair to later update the index, allowing for proper sorting + // TODO: Try to fully remove RefPairs + std::vector fF; + + for (const RefPair& p : F) + { +#ifdef DEBUG + LOG_DEBUG << (char)p.first << ":" << p.second->support << std::endl; +#endif + fF.push_back(p); + } + + std::sort(std::begin(fF), std::end(fF), [](const RefPair& a, const RefPair& b) { return a.second->item() > b.second->item(); }); + + std::sort(std::begin(fF), std::end(fF), [](const RefPair& a, const RefPair& b) { return a.second->support > b.second->support; }); + + for (std::size_t i = 0; i < fF.size(); i++) + { + fF[i].second->SetIdx(i); +#ifdef DEBUG + LOG_DEBUG << (char)fF[i].first << ":" << i << std::endl; +#endif + } + + timerSub.Start(); + + for (TransactionC& trans : db) + { + std::sort(std::begin(trans), std::end(trans), [](const ItemRef& a, const ItemRef& b) { return *a.pFRef > *b.pFRef; }); + } + + std::sort(std::begin(db), std::end(db), [](const TransactionC& a, const TransactionC& b) { + std::size_t l = a.size() > b.size() ? b.size() : a.size(); + for (std::size_t i = 0; i < l; i++) + { + if (a[i] != b[i]) + { + if (a[i].Idx() > b[i].Idx()) + return false; + else + return true; + } + } + + if (a.size() == b.size()) + return false; + + if (a.size() > b.size()) + return true; + else + return false; + }); + + std::reverse(std::begin(db), std::end(db)); + + std::vector known; + + std::sort(std::begin(fF), std::end(fF), [](const RefPair& a, const RefPair& b) { return a.second->Idx() < b.second->Idx(); }); + + timerSub.Stop(); + LOG_VERBOSE << "Sorting done after: " << timerSub << std::endl; + + m_tree = new FPTree(fF, m_pIdx2Id, m_pId2Item, &m_memory); + + for (TransactionC& trans : db) + m_tree->Add(trans, 1); + + m_initTime.Stop(); + LOG_VERBOSE << "Creating Tree done after: " << m_initTime << std::endl; + +#ifdef DEBUG + m_tree->PrintTree(); +#endif + + LOG_VERBOSE << "Tree Cnt: " << m_tree->cnt << std::endl; + } + + ~FPGrowth() + { + delete[] m_pDataObjs; + delete[] m_pThreadMem; + delete[] m_pPattern; + delete[] m_pIdx2Id; + delete[] m_pId2Item; + delete m_tree; + delete m_pClosedDetect; + } + + const uint32_t& GetMinPatternLen() const + { + return m_minPatternLen; + } + + const uint32_t& GetMaxPatternLen() const + { + return m_maxPatternLen; + } + + const std::size_t& GetItemCount() const + { + return m_maxItemCnt; + } + + const ItemC* GetId2Item() const + { + return m_pId2Item; + } + + std::size_t GetPatternCount() const + { + std::size_t cnt = 0; + for (std::size_t i = 0; i < m_tree->cnt; i++) + cnt += m_pPattern[i].GetCount(); + + return cnt; + } + + const Pattern* Growth() + { + Timer t; + t.Start(); + if (!growthTop(m_tree)) return nullptr; + + t.Stop(); + LOG_INFO_EVAL << "\x1B[31mRuntime:\x1B[0m " << t + m_initTime << " - Frequent Item-Sets: " << GetPatternCount() << std::endl; + return m_pPattern; + } + +private: + bool project(const int32_t& tId, FPTree* pDst, const FPTree* pSrc, const std::size_t& id) + { + memset(m_pDataObjs[tId].m_pSubs, 0, id * sizeof(Support)); + FPNode* pNode; + FPNode* pAnc; + + for (pNode = pSrc->pHeads[id].list; pNode; pNode = pNode->succ) + { + for (pAnc = pNode->parent; pAnc->id != IDX_MAX; pAnc = pAnc->parent) + { + m_pDataObjs[tId].m_pSubs[pAnc->id] += pNode->support; + } + } + + Support n = 0; + FPHead* pH; + + for (std::size_t i = 0; i < id; i++) + { + if (m_pDataObjs[tId].m_pSubs[i] < m_minSupport) + { + // Invalidate + m_pDataObjs[tId].m_pSubs[i] = SUPP_MAX; + continue; + } + + pH = pDst->pHeads + n; + pH->item = pSrc->pHeads[i].item; + pH->support = m_pDataObjs[tId].m_pSubs[i]; + pH->list = nullptr; + pH->pMemory = pSrc->pMemory; + m_pDataObjs[tId].m_pSubs[i] = n++; + } + + if (n == 0) return false; + + // As the Tree is reused for several iterations initialize cnt and root support here + pDst->cnt = n; + pDst->root.support = 0; + + std::size_t i; + for (pNode = pSrc->pHeads[id].list; pNode; pNode = pNode->succ) + { + std::size_t* d = m_pDataObjs[tId].m_pMap + id; + for (pAnc = pNode->parent; pAnc->id != IDX_MAX; pAnc = pAnc->parent) + { + if ((i = m_pDataObjs[tId].m_pSubs[pAnc->id]) != SUPP_MAX) + *--d = i; + } + + pDst->Add(d, (m_pDataObjs[tId].m_pMap + id) - d, pNode->support); + } + + return true; + } + + void beginPattern(const int32_t& tId) + { + if (!m_pDataObjs[tId].m_patternOpen) + { + m_pDataObjs[tId].m_patternOpen = true; + std::memset(m_pDataObjs[tId].m_pAdded, 0, m_maxItemCnt); + std::memset(m_pDataObjs[tId].m_pAddedPerfExt, 0, m_maxItemCnt); + m_pDataObjs[tId].m_lastIDCnt = 0; + m_pDataObjs[tId].m_perfExtIDCnt = 0; +#ifdef DEBUG + LOG_DEBUG << std::endl + << std::endl + << "--- BEGIN PATTERN ---" << std::endl; +#endif + } + } + + bool addPatternElement(const int32_t& tId, const ItemID& item, const Support& supp) + { + if (supp < m_minSupport) return true; + if (!m_pDataObjs[tId].m_patternOpen) return true; + + if (!m_pDataObjs[tId].m_pAddedPerfExt[item] && !m_pDataObjs[tId].m_pAdded[item]) + { +#ifdef DEBUG + LOG_DEBUG << "itemID=" << item << "; item=" << (char)m_pId2Item[item] << "; supp=" << supp << std::endl; +#endif + if (m_pClosedDetect->Add(item, supp) > 0) + { + m_pDataObjs[tId].m_pAdded[item] = true; + m_pDataObjs[tId].m_pSupports[m_pDataObjs[tId].m_lastIDCnt] = supp; + m_pDataObjs[tId].m_pLastID[m_pDataObjs[tId].m_lastIDCnt++] = item; + + if (m_pDataObjs[tId].m_lastIDCnt >= m_maxItemCnt) LOG_ERROR << "ERROR: lastIDCnt >= maxItemCnt" << std::endl; + } + else + return false; + } + + return true; + } + + void addPerfectExt(const int32_t& tId, const ItemID& item, const Support& supp) + { + if (supp < m_minSupport) return; + if (!m_pDataObjs[tId].m_patternOpen) return; + + if (!m_pDataObjs[tId].m_pAddedPerfExt[item] && !m_pDataObjs[tId].m_pAdded[item]) + { + m_pDataObjs[tId].m_pAddedPerfExt[item] = true; + m_pDataObjs[tId].m_pPerfExtIDs[m_pDataObjs[tId].m_perfExtIDCnt++] = item; + } + } + + void pp(Pattern& results, const ItemID* pIDs, const std::size_t& size, const std::size_t& pos, const std::size_t& minLen, PatternType* pBase, std::size_t basePos, const Support& supp, const ItemC* pId2Item, const Support& maxSupport, const std::size_t& minNeuronCount, const ItemC& winLen) + { + pBase[basePos++] = m_pId2Item[pIDs[pos]]; + for (std::size_t i = pos + 1; i < size; i++) + pp(results, pIDs, size, i, minLen, pBase, basePos, supp, pId2Item, maxSupport, minNeuronCount, winLen); + + if (basePos >= minLen) + results.AddPattern(basePos, supp, pBase, pId2Item, maxSupport, minNeuronCount, winLen); + } + + void endLocalPattern(const int32_t& tId, const int64_t& pId, const ItemID& item) + { + UNUSED(item); + if (m_pDataObjs[tId].m_patternOpen) + { + size_t combLength = m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt; + if (combLength >= m_minPatternLen && (m_maxPatternLen == 0 || combLength <= m_maxPatternLen)) + { + Support s = m_pDataObjs[tId].m_pSupports[m_pDataObjs[tId].m_lastIDCnt - 1]; +#ifdef ALL_PATTERN + for (std::size_t i = 0; i < m_pDataObjs[tId].m_lastIDCnt; i++) + m_pDataObjs[tId].m_pPatternBase[i] = m_pDataObjs[tId].m_pLastID[i] | (static_cast(m_pDataObjs[tId].m_pSupports[i]) << 32); + +#ifdef PERF_EXT_EXPANSION + // TODO: Add maxPatternLength + for (std::size_t i = 0; i < m_pDataObjs[tId].m_perfExtIDCnt; i++) + pp(m_pPattern[pId], m_pDataObjs[tId].m_pPerfExtIDs, m_pDataObjs[tId].m_perfExtIDCnt, i, m_minPatternLen, m_pDataObjs[tId].m_pPatternBase, static_cast(m_pDataObjs[tId].m_lastIDCnt), s, GetId2Item(), m_maxSupport, m_minNeuronCount, m_winLen); + + if (m_pDataObjs[tId].m_lastIDCnt >= m_minPatternLen && (m_maxPatternLen == 0 || m_pDataObjs[tId].m_lastIDCnt <= m_maxPatternLen)) + m_pPattern[pId].AddPattern(static_cast(m_pDataObjs[tId].m_lastIDCnt), s, m_pDataObjs[tId].m_pPatternBase, GetId2Item(), m_maxSupport, m_minNeuronCount, m_winLen); + +#else + for (std::size_t i = m_pDataObjs[tId].m_lastIDCnt; i < m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt; i++) + m_pDataObjs[tId].m_pPatternBase[i] = m_pDataObjs[tId].m_pPerfExtIDs[i - m_pDataObjs[tId].m_lastIDCnt] | (static_cast(0) << 32); + m_pPattern[pId].AddPattern(static_cast(m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt), s, m_pDataObjs[tId].m_pPatternBase, GetId2Item(), static_cast(m_maxSupport), static_cast(m_minNeuronCount), m_winLen); +#endif +#else // Only extract closed pattern + Support r = m_pClosedDetect->GetSupport(); + +#ifdef DEBUG + LOG_DEBUG << "s=" << s << "; r=" << r << std::endl; +#endif + if (r < s) + { + int32_t k = static_cast(m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt); + + for (std::size_t i = 0; i < m_pDataObjs[tId].m_lastIDCnt; i++) + m_pDataObjs[tId].m_pPatternBase[i] = m_pId2Item[m_pDataObjs[tId].m_pLastID[i]]; + for (std::size_t i = m_pDataObjs[tId].m_lastIDCnt; i < m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt; i++) + m_pDataObjs[tId].m_pPatternBase[i] = m_pId2Item[m_pDataObjs[tId].m_pPerfExtIDs[i - m_pDataObjs[tId].m_lastIDCnt]]; + + std::memcpy(m_pDataObjs[tId].m_pCMem, m_pDataObjs[tId].m_pLastID, m_pDataObjs[tId].m_lastIDCnt * sizeof(ItemID)); + std::memcpy(m_pDataObjs[tId].m_pCMem + m_pDataObjs[tId].m_lastIDCnt, m_pDataObjs[tId].m_pPerfExtIDs, m_pDataObjs[tId].m_perfExtIDCnt * sizeof(ItemID)); +#ifdef DEBUG + for (std::size_t i = 0; i < m_pDataObjs[id].m_lastIDCnt + m_pDataObjs[id].m_perfExtIDCnt; i++) + LOG_DEBUG << m_pDataObjs[id].m_pCMem[i] << " "; + LOG_DEBUG << std::endl; +#endif + + m_pClosedDetect->Update(m_pDataObjs[tId].m_pCMem, k, s); + m_pPattern[pId].AddPattern(static_cast(m_pDataObjs[tId].m_lastIDCnt + m_pDataObjs[tId].m_perfExtIDCnt), s, m_pDataObjs[tId].m_pPatternBase, GetId2Item(), static_cast(m_maxSupport), static_cast(m_minNeuronCount), m_winLen); +#ifdef DEBUG + LOG_DEBUG << std::endl + << std::endl; +#endif + } +#endif + } + +#ifndef ALL_PATTERN + m_pClosedDetect->Remove(1); +#endif + + // pre-decrement due to the post increment during the setting + if (m_pDataObjs[tId].m_lastIDCnt > 0) + m_pDataObjs[tId].m_pAdded[m_pDataObjs[tId].m_pLastID[--m_pDataObjs[tId].m_lastIDCnt]] = false; + + for (std::size_t i = 0; i < m_pDataObjs[tId].m_perfExtIDCnt; i++) + m_pDataObjs[tId].m_pAddedPerfExt[m_pDataObjs[tId].m_pPerfExtIDs[i]] = false; + m_pDataObjs[tId].m_perfExtIDCnt = 0; + } + } + + void EndPattern(const int32_t& tId, const ItemID& item) + { + if (m_pDataObjs[tId].m_patternOpen && m_pDataObjs[tId].m_pLastID[0] == item) + { +#ifdef DEBUG + LOG_DEBUG << "Pattern-End: " << (char)m_pId2Item[item] << "; id=" << item << std::endl; +#endif + m_pDataObjs[tId].m_patternOpen = false; + } + } + + bool growthTop(FPTree* pTree) + { +#ifdef USE_MPI + const int ROOT_RANK = 0; + int rank; + int procs; + MPI_Init(NULL, NULL); + + MPI_Comm_size(MPI_COMM_WORLD, &procs); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + + LOG_VERBOSE << "PROCS: " << procs << " | Rank: " << rank << std::endl; +#endif + + FPTree** ppDst = new FPTree*[m_objs](); + +#ifdef WITH_SIG_TERM + if (sigAborted()) throw(FPGException("CTRL-C abort")); +#endif + + if (pTree->cnt > 1) + { + for (int32_t i = 0; i < m_objs; i++) + { + ppDst[i] = new FPTree(m_tree->cnt - 1, m_tree->pIdx2Id, m_tree->pId2Item, &m_pThreadMem[i]); + ppDst[i]->root.id = IDX_MAX; + ppDst[i]->root.succ = nullptr; + ppDst[i]->root.parent = nullptr; + } + } + + int64_t start = 0; + int64_t end = static_cast(pTree->cnt); + int64_t inc = 1; + bool error = false; + +#ifdef USE_MPI + const int64_t iterationsPerProc = static_cast(pTree->cnt / procs); + start = rank; + inc = procs; +#endif + +#ifdef USE_OPENMP +#pragma omp parallel for schedule(dynamic) +#endif +#ifdef ALL_PATTERN + for (int64_t i = start; i < end; i += inc) +#else + for (int64_t i = end - 1; i >= start; i -= inc) +#endif + { +#ifdef _MSC_VER + if (error) continue; +#endif +#ifdef USE_OPENMP + int32_t tId = omp_get_thread_num(); +#else + int32_t tId = 0; +#endif + FPHead* pH = pTree->pHeads + i; + beginPattern(tId); + if (!addPatternElement(tId, pH->item, pH->support)) + continue; + + FPNode* pNode = pH->list; + if (pNode && !pNode->succ) + { + for (FPNode* pAnc = pNode->parent; pAnc->id != IDX_MAX; pAnc = pAnc->parent) + addPerfectExt(tId, pTree->pHeads[pAnc->id].item, pTree->pHeads[pAnc->id].support); + } + else if (ppDst[tId]) + { + if (project(tId, ppDst[tId], pTree, static_cast(i))) + { + // Use boolean return because throwing exceptions + // in a multi-threaded setup results in forceful + // termination of the application + if (!growth(tId, i, ppDst[tId])) + { + error = true; +#ifndef _MSC_VER + i = end; +#endif + } + } + } + + if (!error) + { + endLocalPattern(tId, i, pH->item); + + EndPattern(tId, pH->item); + +#ifdef USE_MPI + if (rank == ROOT_RANK) + { +#endif +#ifdef ALL_PATTERN + if (tId == 0) + LOG_INFO << "\r" << i + 1 << " / " << pTree->cnt << " Done" << std::flush; +#else + if (tId == 0) + LOG_INFO << "\r" << pTree->cnt - i << " / " << pTree->cnt << " Done" << std::flush; +#endif +#ifdef USE_MPI + } +#endif + } + } + + if (error) throw(FPGException("Ctrl-C Interrupt")); + + for (int32_t i = 0; i < m_objs; i++) + if (ppDst[i]) delete ppDst[i]; + + delete[] ppDst; + +#ifdef USE_MPI + if (rank == ROOT_RANK) +#endif + LOG_INFO << "\r" << pTree->cnt << " / " << pTree->cnt << " Done" << std::endl; + +#ifdef USE_MPI + const int MSG_TAG = 0; + + if (rank == ROOT_RANK) + { + Timer comTime; + comTime.Start(); + MPI_Status status; + int64_t fullCnt = 0; + + for (int i = 0; i < procs; i++) + { + if (i == ROOT_RANK) continue; + int dataCnt; + int procResCnt = 0; + + for (uint32_t j = 0; j < iterationsPerProc; j++) + { + std::vector data; + MPI_Probe(i, MSG_TAG, MPI_COMM_WORLD, &status); + MPI_Get_count(&status, MPI_UNSIGNED_LONG_LONG, &dataCnt); + data.resize(dataCnt); + MPI_Recv(data.data(), dataCnt, MPI_UNSIGNED_LONG_LONG, i, MSG_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE); + procResCnt += dataCnt; + + for (int k = 0; k < dataCnt; k += data[k] + Pattern::OFFSET) + m_pPattern[j * procs + i].AddPattern(data[k], data[k + 1], &data[k + 2]); + } + LOG_VERBOSE << "Recieved " << procResCnt << " values from Rank: " << i << std::endl; + fullCnt += procResCnt; + } + comTime.Stop(); + LOG_INFO_EVAL << "Merged all results in Rank: " << ROOT_RANK << " final count: " << fullCnt << " Done after: " << comTime << std::endl; + } + else + { + for (uint32_t i = rank; i < static_cast(pTree->cnt); i += procs) + { + std::vector data; + for (const PatternType* pPtr : m_pPattern[i]) + { + for (PatternType i = 0; i < pPtr[Pattern::LEN_IDX] + Pattern::OFFSET; i++) + data.push_back(pPtr[i]); + } + + MPI_Send(data.data(), static_cast(data.size()), MPI_UNSIGNED_LONG_LONG, ROOT_RANK, MSG_TAG, MPI_COMM_WORLD); + } + } + MPI_Finalize(); + + return rank == ROOT_RANK; +#endif + + return true; + } + + bool growth(const int32_t& tId, const int64_t& pId, FPTree* pTree) + { + FPTree* pDst = nullptr; + FPHead* pH = nullptr; + FPNode* pNode = nullptr; + FPNode* pAnc = nullptr; + +#ifdef WITH_SIG_TERM + if (sigAborted()) return false; //throw(FPGException("CTRL-C abort")); +#endif + + if (pTree->cnt > 1) + { + pDst = new FPTree(m_tree->cnt - 1, m_tree->pIdx2Id, m_tree->pId2Item, &m_pThreadMem[tId]); + pDst->root.id = IDX_MAX; + pDst->root.succ = nullptr; + pDst->root.parent = nullptr; + } + + pTree->pMemory->PushState(); + + for (int64_t i = pTree->cnt - 1; i > -1; i--) + { + pH = pTree->pHeads + i; + if (!addPatternElement(tId, pH->item, pH->support)) + continue; + + pNode = pH->list; + if (pNode && !pNode->succ) + { + for (pAnc = pNode->parent; pAnc->id != IDX_MAX; pAnc = pAnc->parent) + addPerfectExt(tId, pTree->pHeads[pAnc->id].item, pTree->pHeads[pAnc->id].support); + } + else if (pDst) + { + if (project(tId, pDst, pTree, static_cast(i))) + { + if (!growth(tId, pId, pDst)) + return false; + } + } + + endLocalPattern(tId, pId, pH->item); + } + + pTree->pMemory->PopState(); + if (pDst) delete pDst; + return true; + } + + FrequencyMap getFrequency(const Transactions& transactions) + { + FrequencyMap frequency; + for (const Transaction& transaction : transactions) + { + for (const ItemC& item : transaction) + frequency[item]++; + } + + return frequency; + } + + bool reduceItems(Transactions& transactions, FrequencyMap& frequency) + { + bool reduced = false; + for (Transaction& trans : transactions) + { + for (Transaction::iterator it = std::begin(trans); it != std::end(trans); it++) + { + if (frequency[*it] < m_minSupport) + { + it = trans.erase(it); + if (it != std::begin(trans)) + it--; // Decrement because erase returns the iterater after the deleted element which would be skipped due to the loop increment + reduced = true; + + if (it == std::end(trans)) break; + } + } + } + + map_erase_if(frequency, [&minSupport = m_minSupport](const std::pair& p) { return p.second < minSupport; }); + + return reduced; + } + + void reduceTransactions(Transactions& transactions) + { + std::experimental::erase_if(transactions, [&minPatternLen = m_minPatternLen](const Transaction& t) { return t.size() < minPatternLen; }); + } + +private: + Support m_minSupport; + uint32_t m_minPatternLen; + uint32_t m_maxPatternLen; + ItemC m_winLen; + uint32_t m_maxSupport; + uint32_t m_minNeuronCount; + FPTree* m_tree; + std::size_t m_maxItemCnt; + int32_t m_objs; + + struct DataObjs + { + DISABLE_COPY_ASSIGN_MOVE(DataObjs) + + Support* m_pSubs; + std::size_t* m_pMap; + + bool* m_pAdded; + bool* m_pAddedPerfExt; + ItemID* m_pLastID; + ItemID* m_pPerfExtIDs; + Support* m_pSupports; + std::size_t m_lastIDCnt; + std::size_t m_perfExtIDCnt; + + bool m_patternOpen; + PatternType* m_pPatternBase; +#ifndef ALL_PATTERN + ItemID* m_pCMem; +#endif + DataObjs() : + m_pSubs(nullptr), + m_pMap(nullptr), + m_pAdded(nullptr), + m_pAddedPerfExt(nullptr), + m_pLastID(nullptr), + m_pPerfExtIDs(nullptr), + m_pSupports(nullptr), + m_lastIDCnt(0), + m_perfExtIDCnt(0), + m_patternOpen(false), + m_pPatternBase(nullptr) +#ifndef ALL_PATTERN + , + m_pCMem(nullptr) +#endif + {} + + ~DataObjs() + { + delete[] m_pSubs; + delete[] m_pMap; + delete[] m_pAdded; + delete[] m_pAddedPerfExt; + delete[] m_pLastID; + delete[] m_pPerfExtIDs; + delete[] m_pSupports; + delete[] m_pPatternBase; +#ifndef ALL_PATTERN + delete[] m_pCMem; +#endif + } + + void Init(const std::size_t& elements) + { + m_pSubs = new Support[elements](); + m_pMap = new std::size_t[elements](); + + m_pAdded = new bool[elements](); + m_pAddedPerfExt = new bool[elements](); + m_pLastID = new ItemID[elements](); + m_pPerfExtIDs = new ItemID[elements](); + m_pSupports = new Support[elements](); + + m_pPatternBase = new PatternType[elements](); +#ifndef ALL_PATTERN + m_pCMem = new ItemID[elements](); +#endif + } + }; + + DataObjs* m_pDataObjs; + + uint32_t* m_pIdx2Id; + ItemC* m_pId2Item; + + FPNMemory m_memory; + FPNMemory* m_pThreadMem; + Pattern* m_pPattern; + + ClosedDetect* m_pClosedDetect; + Timer m_initTime; +}; + +void PostProcessing(const Pattern* pPattern, const std::size_t& maxC, const std::size_t& itemCount, const std::size_t& minPatternLength, const PatternType& winLen, const ItemC* pId2Item, std::vector& res) +{ + LOG_VERBOSE << "Result Filtering ... " << std::flush; + Timer timer; + timer.Start(); + + for (int64_t i = itemCount - 1; i > -1; i--) + { + for (const PatternType* pPtr : pPattern[i]) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) throw(FPGException("CTRL-C abort")); +#endif + const PatternType* pStart = pPtr + Pattern::DATA_IDX; + const PatternType* pEnd = pStart + pPtr[Pattern::LEN_IDX]; + if (pPtr[Pattern::LEN_IDX] <= maxC) + { + if (std::any_of(pStart, pEnd, [&winLen, &pId2Item](const PatternType& i) { return ((pId2Item[i & 0xFFFFFFFF]) % winLen) == 0; })) + { + std::set v; + std::transform(pStart, pEnd, std::inserter(v, std::begin(v)), [&winLen, &pId2Item](const PatternType& i) { return (pId2Item[i & 0xFFFFFFFF]) / winLen; }); + + // TODO: Maybe remove vector here and find different way + if (v.size() >= minPatternLength) + res.push_back(pPtr); + } + } + } + } + + std::size_t cnt = 0; + for (std::size_t i = 0; i < itemCount; i++) + cnt += pPattern[i].GetCount(); + + timer.Stop(); + LOG_VERBOSE << "Done after: " << timer << std::endl; + LOG_INFO << "Reduction: " << cnt << " -> " << res.size() << std::endl; +} + +void ClosedDetection(const FPGrowth& fp, const Pattern* pPattern, std::vector& closed) +{ + const std::size_t itemCount = fp.GetItemCount(); + const ItemC* pId2Item = fp.GetId2Item(); + if (fp.GetPatternCount() == 0) + { + LOG_INFO_EVAL << "No itemsets provided, skipping Closed Detection" << std::endl; + return; + } + + Timer timer; + + LOG_INFO_EVAL << "Closed Detection ... " << std::flush; + + timer.Start(); + + ClosedDetect cd(itemCount); + PatternType* pM = new PatternType[itemCount]; + PatternType* pPfExt = new PatternType[itemCount]; + PatternType* pItems = new PatternType[itemCount]; + bool* pAdded = new bool[itemCount](); + + ItemID base = ITEM_ID_MAX; + int32_t k = 0; + + for (int64_t patI = itemCount - 1; patI > -1; patI--) + { + for (const PatternType* pp : pPattern[patI]) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) throw(FPGException("CTRL-C abort")); +#endif + int32_t pfExtCnt = 0; + bool skip = false; + + if (base != pp[Pattern::DATA_IDX]) + { + cd.Remove(k); + base = pp[Pattern::DATA_IDX]; + std::memset(pAdded, 0, itemCount * sizeof(bool)); + k = 0; + } + + for (int32_t i = 0; i < k; i++) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) throw(FPGException("CTRL-C abort")); +#endif + // TODO: Probably can start at 1 here + if (pItems[i] != (pp[Pattern::DATA_IDX + i] & 0xFFFFFFFF)) + { + for (int32_t j = i; j < k; j++) + { + pAdded[pItems[j]] = false; + cd.Remove(1); + } + + k = i; + break; + } + } + + for (PatternType p = 0; p < pp[Pattern::LEN_IDX]; p++) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) throw(FPGException("CTRL-C abort")); +#endif + PatternType i = pp[Pattern::DATA_IDX + p]; + Support supp = i >> 32; + ItemID item = i & 0xFFFFFFFF; + if (supp == 0) + pPfExt[pfExtCnt++] = item; + else if (!pAdded[item]) + { + if (cd.Add2(item, supp) > 0) + { + pItems[k++] = item; + pAdded[item] = true; + } + else + { + skip = true; + break; + } + } + } + + if (skip) continue; + + Support s = static_cast(pp[Pattern::SUPP_IDX]); + Support r = cd.GetSupport(); + + if (static_cast(k) + pfExtCnt == pp[Pattern::LEN_IDX]) + { +#ifdef DEBUG + LOG_DEBUG << "s=" << s << "; r=" << r << std::endl; +#endif + if (r < s) + { + std::memcpy(pM, pItems, k * sizeof(ItemID)); + std::memcpy(pM + k, pPfExt, pfExtCnt * sizeof(ItemID)); + +#ifdef DEBUG + for (int32_t i = 0; i < k + pfExtCnt; i++) + LOG_DEBUG << pM[i] << " "; + LOG_DEBUG << std::endl; +#endif + + cd.Update(pM, k + pfExtCnt, s); + + PatternPair ppN; + ppN.first.reserve(k + pfExtCnt); + ppN.second = s; + + for (PatternType p = 0; p < pp[Pattern::LEN_IDX]; p++) + { + PatternType id = pp[Pattern::DATA_IDX + p]; + ppN.first.push_back(static_cast(pId2Item[id & 0xFFFFFFFF])); + } + + closed.push_back(ppN); + +#ifdef DEBUG + LOG_DEBUG << std::endl + << std::endl; +#endif + } + + if (k > 0) pAdded[pItems[--k]] = false; + cd.Remove(1); + } + } + } + + delete[] pM; + delete[] pPfExt; + delete[] pItems; + delete[] pAdded; + + timer.Stop(); + LOG_INFO_EVAL << "Done after: " << timer << std::endl; + LOG_INFO << "Closed Pattern: " << closed.size() << std::endl; +} diff --git a/elephant/spade_src/include/FPNode.h b/elephant/spade_src/include/FPNode.h new file mode 100644 index 000000000..53465cffb --- /dev/null +++ b/elephant/spade_src/include/FPNode.h @@ -0,0 +1,100 @@ +/* + * File: FPNode.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "Types.h" +#include "Logger.h" + +#include +#include +#include + +struct FPNode +{ + std::size_t id; + Support support; + struct FPNode* parent; + struct FPNode* succ; +#ifdef DEBUG + ItemC item; +#endif + + FPNode() : + id(std::numeric_limits::max()), + support(0), + parent(nullptr), + succ(nullptr) +#ifdef DEBUG + , item(0) +#endif + {} + +#ifdef DEBUG + ~FPNode() + { + parent = nullptr; + succ = nullptr; + } +#endif + + void SetFreeNode(FPNode* pNode) + { + parent = pNode; + } + + FPNode* GetFreeNode() const + { + return parent; + } + + void PrintTree(const std::string& prefix = "") const + { + const std::string space = " "; + const std::string connectSpace = u8"│ "; + const bool isLast = parent == nullptr; + + LOG_VERBOSE << prefix; + LOG_VERBOSE << (isLast ? u8"└──" : u8"├──"); + // print the value of the node +#ifdef DEBUG + LOG_DEBUG << (char)item << ":" << support << std::endl; +#endif + + // enter the next tree level - left and right branch + if (parent != nullptr) + parent->PrintTree(prefix + (isLast ? space : connectSpace)); + if (succ != nullptr) + succ->PrintTree(prefix/* + (isLast ? space : connectSpace)*/); + } + + friend std::ostream& operator<<(std::ostream& os, const FPNode& rhs) + { + os << "id=" << rhs.id << "; support=" << rhs.support << "; parent=" << rhs.parent << "; succ=" << rhs.succ; + return os; + } + +}; diff --git a/elephant/spade_src/include/FPTree.h b/elephant/spade_src/include/FPTree.h new file mode 100644 index 000000000..d79cf5b9a --- /dev/null +++ b/elephant/spade_src/include/FPTree.h @@ -0,0 +1,202 @@ +/* + * File: FPTree.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "HeapAlloc.h" +#include "Types.h" +#include "Logger.h" +#include "Utils.h" +#include "Memory.h" +#include "FrequencyRef.h" + + +struct FPHead +#ifdef _WIN32 + : public HeapAlloc +#endif +{ + ItemID item; + Support support; + FPNode* list; + FPNMemory* pMemory; +}; + +struct FPTree +#ifdef _WIN32 + : public HeapAlloc +#endif +{ + DISABLE_COPY_ASSIGN_MOVE(FPTree) + + std::size_t cnt; + FPNode root; + FPHead* pHeads; + std::uint32_t* pIdx2Id; + ItemC* pId2Item; + FPNMemory* pMemory; + + FPTree() : + cnt(0), + root(), + pHeads(nullptr), + pIdx2Id(nullptr), + pId2Item(nullptr), + pMemory(nullptr) + {} + + FPTree(const std::size_t& items, uint32_t* pIdx2Id_g, ItemC* pId2Item_g, FPNMemory* pMem) : + cnt(items), + root(), + pHeads(nullptr), + pIdx2Id(pIdx2Id_g), + pId2Item(pId2Item_g), + pMemory(pMem) + { + pHeads = new FPHead[cnt]; + } + + FPTree(const std::vector& F, uint32_t* pIdx2Id_g, ItemC* pId2Item_g, FPNMemory* pMem) : + cnt(F.size()), + root(), + pHeads(nullptr), + pIdx2Id(pIdx2Id_g), + pId2Item(pId2Item_g), + pMemory(pMem) + { + pHeads = new FPHead[cnt]; + uint32_t id = 0; + for (std::size_t idx = 0; idx < F.size(); idx++) + { + pId2Item[idx] = F[idx].first; + pIdx2Id[idx] = id; + pHeads[id].item = idx; + F[idx].second->SetIdx(idx); + pHeads[id].support = F[idx].second->support; + pHeads[id].list = nullptr; + pHeads[id].pMemory = pMemory; + id++; + } + } + + ~FPTree() + { + delete[] pHeads; + } + + void Add(const TransactionC& trans, const Support& support) + { + std::size_t n = trans.size(); + std::size_t i = 0; + std::size_t id = 0; + FPNode* c; + FPNode* pNode = &root; +#ifdef DEBUG + ItemC item; +#endif + + // Traverse tree until no valid child is found + while (1) + { + pNode->support += support; + if (i >= n) return; +#ifdef DEBUG + item = trans[i].item; +#endif + id = pIdx2Id[trans[i++].Idx()]; + c = pHeads[id].list; + if (!c || (c->parent != pNode)) break; + pNode = c; + } + + // Create ne children until the transaction processed + while (1) + { + c = pMemory->Alloc(); + c->id = id; + c->support = support; + c->parent = pNode; + c->succ = pHeads[id].list; +#ifdef DEBUG + c->item = item; +#endif + pHeads[id].list = pNode = c; + if (i >= n) return; +#ifdef DEBUG + item = trans[i].item; +#endif + id = pIdx2Id[trans[i++].Idx()]; + } + } + + void Add(const std::size_t* pData, const std::size_t& n, const Support& support) + { + std::size_t i = 0; + std::size_t id = 0; + FPNode* c; + FPNode* pNode = &root; + + // Traverse tree until no valid child is found + while (1) + { + pNode->support += support; + if (i >= n) return; + id = pData[i++]; + c = pHeads[id].list; + if (!c || (c->parent != pNode)) break; + pNode = c; + } + + // Create new children until the transaction processed + while (1) + { + c = pMemory->Alloc(); + c->id = id; + c->support = support; + c->parent = pNode; + c->succ = pHeads[id].list; +#ifdef DEBUG + c->item = pId2Item[pHeads[id].item]; +#endif + pHeads[id].list = pNode = c; + if (i >= n) return; + id = pData[i++]; + } + } + + void PrintTree() const + { + LOG_VERBOSE << "root" << std::endl; + + + // Enter the next tree level - left and right branch + for (std::size_t i = 0; i < cnt; i++) + { + if (pHeads[i].list != nullptr) + pHeads[i].list->PrintTree(""); + } + } +}; diff --git a/elephant/spade_src/include/FrequencyRef.h b/elephant/spade_src/include/FrequencyRef.h new file mode 100644 index 000000000..8a8be4cc0 --- /dev/null +++ b/elephant/spade_src/include/FrequencyRef.h @@ -0,0 +1,188 @@ +/* + * File: FrequencyRef.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "Types.h" + +#include + +struct FrequencyRef +{ + Support support; + + FrequencyRef(const std::size_t idx) : + support(0), + m_idx(idx), + m_refs() + {} + + ~FrequencyRef(); + + ItemC item() const; + + const std::size_t& Idx() const + { + return m_idx; + } + + void SetIdx(const std::size_t& idx) + { + m_idx = idx; + } + + bool operator< (const struct FrequencyRef& rhs) const + { + if (support == rhs.support) return m_idx < rhs.m_idx; + return support < rhs.support; + } + + bool operator> (const struct FrequencyRef& rhs) const + { + if (support == rhs.support) return m_idx < rhs.m_idx; + return support > rhs.support; + } + + bool operator< (const uint64_t& sup) const + { + return support < sup; + } + + bool operator> (const uint64_t& sup) const + { + return support > sup; + } + + bool operator== (const struct FrequencyRef& rhs) const + { + return this->support == rhs.support; + } + + void Inc(struct ItemRef* pItemRef); + + void Dec(struct ItemRef* pItemRef) + { + UNUSED(pItemRef); + support--; + m_refs.erase(std::remove(std::begin(m_refs), std::end(m_refs), pItemRef), std::end(m_refs)); + } + +private: + std::size_t m_idx; + std::vector m_refs; +}; + + +struct ItemRef +{ + ItemC item; + struct FrequencyRef* pFRef; + + ItemRef(const ItemC& item) : + item(item), + pFRef(nullptr) + {} + + ItemRef(const ItemRef& ref) : + item(ref.item), + pFRef(ref.pFRef) + {} + + ~ItemRef() {} + + ItemRef& operator=(const ItemRef& ref) + { + this->item = ref.item; + this->pFRef = ref.pFRef; + return *this; + } + + + void SetRef(struct FrequencyRef* pRef) + { + pFRef = pRef; + } + + bool operator!= (const ItemRef& rhs) const + { + return item != rhs.item; + } + + bool operator< (const ItemRef& rhs) const + { + return item < rhs.item; + } + + bool operator> (const ItemRef& rhs) const + { + return item > rhs.item; + } + + std::size_t Idx() const + { + if (pFRef == nullptr) return IDX_MAX; + return pFRef->Idx(); + } + +private: + friend std::ostream& operator<<(std::ostream& os, const ItemRef& ref) + { + os << ref.item; + return os; + } +}; + +FrequencyRef::~FrequencyRef() +{ + // Invalidate all related items + for (ItemRef* pRef : m_refs) + { + if (pRef) pRef->pFRef = nullptr; + } +} + +ItemC FrequencyRef::item() const +{ + return m_refs.front()->item; +} + +void FrequencyRef::Inc(struct ItemRef* pItemRef) +{ + support++; + m_refs.push_back(pItemRef); + pItemRef->SetRef(this); +} + +using FrequencyRefShr = std::shared_ptr; + +using TransactionC = std::vector; +using DataBase = std::vector; + + +#define ITEM_PAIR ItemC, FrequencyRefShr + +using FrequencyMapC = std::map; +using RefPair = std::pair; diff --git a/elephant/spade_src/include/HeapAlloc.h b/elephant/spade_src/include/HeapAlloc.h new file mode 100644 index 000000000..31ae57479 --- /dev/null +++ b/elephant/spade_src/include/HeapAlloc.h @@ -0,0 +1,124 @@ +/* + * File: HeapAlloc.h + * Copyright (c) 2021 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#ifdef _WIN32 + +// In a multi-threaded environmet the Windows runtime library spends a lot of time waiting +// when allocating memory as each thread uses the same heap. Therefore, by creating a dedicated +// heap for each thread, the wait time is removed and the overall performance increases significantly. +// Implementation based on: https://stackoverflow.com/a/63749764 + +#include "Logger.h" + +#ifndef NOMINMAX +#define NOMINMAX // Disable the build in MIN/MAX macros to prevent collisions +#endif +#include + +namespace +{ +thread_local HANDLE g_tl_heapHandle; + +const char* lastSystemErrorText() +{ + static char err[BUFSIZ]; + FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast(err), 255, NULL); + return err; +} + +HANDLE createNewHeap() +{ + HANDLE handle = HeapCreate(0, 0, 0); + if (handle == nullptr) + LOG_ERROR << "Could not create large object heap" << lastSystemErrorText() << std::endl; + + return handle; +} + +inline bool heapFree(HANDLE handle, void* ptr) +{ + bool success = HeapFree(handle, 0, ptr); + if (!success) + LOG_ERROR << "Failed to free memory: " << lastSystemErrorText() << std::endl; + + return success; +} + +inline void* newImpl(std::size_t bytes) +{ + // Allocate additional space to store the handle for the allocating heap. + std::size_t sz = bytes + sizeof(HANDLE); + + if (g_tl_heapHandle == nullptr) + g_tl_heapHandle = createNewHeap(); + + void* ptr = HeapAlloc(g_tl_heapHandle, 0, sz); + if (ptr) + { + *(reinterpret_cast(ptr)) = g_tl_heapHandle; + return reinterpret_cast((reinterpret_cast(ptr)) + sizeof(HANDLE)); + } + else + throw std::bad_alloc{}; +} + +inline void deleteImpl(void* ptr) +{ + if (!ptr) return; + + void* handlePtr = reinterpret_cast(((reinterpret_cast(ptr)) - sizeof(HANDLE))); + HANDLE handle = *(reinterpret_cast(handlePtr)); + if(handle) + heapFree(handle, handlePtr); +} +} + +class HeapAlloc +{ + public: + void* operator new(std::size_t sz) + { + return newImpl(sz); + } + + void* operator new[](std::size_t sz) + { + return newImpl(sz); + } + + void operator delete(void* ptr) noexcept + { + deleteImpl(ptr); + } + + void operator delete[](void* ptr) noexcept + { + deleteImpl(ptr); + } +}; +#endif diff --git a/elephant/spade_src/include/Logger.h b/elephant/spade_src/include/Logger.h new file mode 100644 index 000000000..a8f55236d --- /dev/null +++ b/elephant/spade_src/include/Logger.h @@ -0,0 +1,124 @@ +/* + * File: Logger.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include +#include + +enum class Verbosity +{ + VB_DEBUG = 0, + VB_VERBOSE = 1, + VB_INFO = 2, + VB_WARNING = 3, + VB_ERROR = 4, + VB_NONE = 255 +}; + +class Logger +{ + using EndlType = std::ostream& (std::ostream&); + +public: + Logger(Verbosity lvl, Verbosity verbosity = Verbosity::VB_VERBOSE) : + m_lvl(lvl), + m_verbosity(verbosity), + m_outStream(std::cout) + {} + + void SetVerbosity(Verbosity v) + { + m_verbosity = v; + } + + Logger& operator<<(EndlType endl) + { + if (m_lvl >= m_verbosity) + m_outStream << endl; + return *this; + } + + template + Logger& operator<<(const T& data) + { + if (m_lvl >= m_verbosity) + m_outStream << data; + return *this; + } + + +private: + Verbosity m_lvl; + Verbosity m_verbosity; + std::ostream& m_outStream; +}; + +static Logger g_debug(Verbosity::VB_DEBUG); +static Logger g_verbose(Verbosity::VB_VERBOSE); +static Logger g_info(Verbosity::VB_INFO); +static Logger g_warning(Verbosity::VB_WARNING); +static Logger g_error(Verbosity::VB_ERROR); + +#ifndef EVAL_MODE +#define LOG_DEBUG g_debug +#define LOG_VERBOSE g_verbose +#define LOG_INFO g_info +#define LOG_WARNING g_warning +#define LOG_ERROR g_error +#else +static Logger g_none(Verbosity::VB_DEBUG, Verbosity::VB_NONE); +#define LOG_DEBUG g_none +#define LOG_VERBOSE g_none +#define LOG_INFO g_none +#define LOG_WARNING g_none +#define LOG_ERROR g_none +#endif + +#define LOG_INFO_EVAL g_info + +void SetVerbosity(Verbosity v) +{ + g_debug.SetVerbosity(v); + g_verbose.SetVerbosity(v); + g_info.SetVerbosity(v); + g_warning.SetVerbosity(v); + g_error.SetVerbosity(v); +} + +template +constexpr typename std::underlying_type::type ToUnderlying(E e) noexcept +{ + return static_cast::type>(e); +} + +Verbosity ToVerbosity(const int32_t& val) +{ + if (val < ToUnderlying(Verbosity::VB_DEBUG) || val > ToUnderlying(Verbosity::VB_ERROR)) + return Verbosity::VB_INFO; + + return static_cast(val); +} \ No newline at end of file diff --git a/elephant/spade_src/include/Memory.h b/elephant/spade_src/include/Memory.h new file mode 100644 index 000000000..2c4f255cf --- /dev/null +++ b/elephant/spade_src/include/Memory.h @@ -0,0 +1,207 @@ +/* + * File: Memory.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "Types.h" +#include "Logger.h" +#include "FPNode.h" +#include "Utils.h" + +#include +#include + +template +class Memory +{ + DISABLE_COPY_ASSIGN_MOVE(Memory) + struct MemoryState + { + std::size_t inUse; + std::size_t nextIdx; + std::size_t memBlock; + T* pFrees; + }; + + +public: + Memory() : + m_elems(0), + m_inUse(0), + m_nextIdx(0), + m_memBlock(0), + m_pMem(), + m_pFrees(nullptr), + m_memStates() + {} + + Memory(const std::size_t& elems) : + m_elems(elems), + m_inUse(0), + m_nextIdx(0), + m_memBlock(0), + m_pMem(), + m_pFrees(nullptr), + m_memStates() + { + allocNewMemBlock(); + } + + ~Memory() + { + for (T* pP : m_pMem) + delete[] pP; + } + + void Init(const std::size_t& elems) + { + m_elems = elems; + allocNewMemBlock(); + } + + void PushState() + { +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Push InUse=" << m_inUse << "; NextIDX=" << m_nextIdx << "; memBlock=" << m_memBlock << std::endl; +#endif + MemoryState ms; + ms.inUse = m_inUse; + ms.nextIdx = m_nextIdx; + ms.memBlock = m_memBlock; + ms.pFrees = m_pFrees; + m_memStates.push(ms); + } + + void PopState() + { + if (m_memStates.empty()) return; + + MemoryState ms = m_memStates.top(); + m_memStates.pop(); +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Pop (before) InUse=" << m_inUse << "; NextIDX=" << m_nextIdx << "; memBlock=" << m_memBlock << std::endl; +#endif + m_inUse = ms.inUse; + m_nextIdx = ms.nextIdx; + m_memBlock = ms.memBlock; + m_pFrees = ms.pFrees; +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Pop (after) InUse=" << m_inUse << "; NextIDX=" << m_nextIdx << "; memBlock=" << m_memBlock << std::endl; +#endif + } + + T* Alloc() + { +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Alloc ... " << std::flush; +#endif + m_inUse++; + if (m_pFrees) + { + T* pNode = m_pFrees; + m_pFrees = pNode->GetFreeNode(); + pNode->SetFreeNode(nullptr); +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "(Free) Done" << std::endl; +#endif + return pNode; + } + + if (m_nextIdx >= m_elems) + allocNewMemBlock(); + +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Done" << std::endl; +#endif + return &m_pMem[m_memBlock - 1][m_nextIdx++]; + } + + void Free(T* pNode) + { +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Free ... " << std::flush; +#endif + pNode->SetFreeNode(m_pFrees); + m_pFrees = pNode; + m_inUse--; +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Done" << std::endl; +#endif + } + + void Clear() + { + m_inUse = 0; + m_memBlock = 1; + m_nextIdx = 0; + m_pFrees = nullptr; + } + +private: + void allocNewMemBlock() + { +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Allocating new Memory Block ... " << std::flush; +#endif + // After restoring a pushed state that was on a different memory block make sure to not allocate the next block again + if (m_memBlock == m_pMem.size()) + m_pMem.push_back(new T[m_elems]()); + + m_memBlock++; + m_nextIdx = 0; +#ifdef MEMORY_VERBOSE + LOG_DEBUG << "Done" << std::endl; +#endif + } + + friend std::ostream& operator<<(std::ostream& os, const Memory& rhs) + { + os << "Elements : " << rhs.m_elems << std::endl; + os << "Mem Blocks: " << rhs.m_memBlock << std::endl; + os << "In Use : " << rhs.m_inUse << std::endl; + os << "Next Idx : " << rhs.m_nextIdx << std::endl; + + for (std::size_t i = 0; i < rhs.m_memBlock; i++) + { + os << "Mem Block [" << i << "]" << std::endl; + for (std::size_t j = 0; j < rhs.m_elems; j++) + os << rhs.m_pMem[i][j] << std::endl; + } + + return os; + } + +private: + std::size_t m_elems; + std::size_t m_inUse; + std::size_t m_nextIdx; + std::size_t m_memBlock; + std::vector m_pMem; + T* m_pFrees; + std::stack m_memStates; +}; + +using FPNMemory = Memory; diff --git a/elephant/spade_src/include/Pattern.h b/elephant/spade_src/include/Pattern.h new file mode 100644 index 000000000..13bf46032 --- /dev/null +++ b/elephant/spade_src/include/Pattern.h @@ -0,0 +1,238 @@ +/* + * File: Pattern.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "Logger.h" +#include "Types.h" +#include "Utils.h" + +#include + +class Pattern +{ + DISABLE_COPY_ASSIGN_MOVE(Pattern) + + static constexpr std::size_t BLOCK_SIZE = 16384; + +public: + static constexpr PatternType OFFSET = 2; + static constexpr PatternType LEN_IDX = 0; + static constexpr PatternType SUPP_IDX = 1; + static constexpr PatternType DATA_IDX = 2; + +public: + Pattern() : + m_nextIdx(0), + m_block(0), + m_patternCnt(0), + m_mem(), + m_pEndPtr(nullptr) + { + allocNewPatternBlock(); + } + + ~Pattern() + { + for (std::size_t i = 0; i < m_block; i++) + delete[] m_mem[i]; + } + + template + class iterator + { + DISABLE_COPY_ASSIGN_MOVE(iterator) + public: + using ValueType = T; + using Reference = T&; + using Pointer = T*; + + explicit iterator(std::vector mem, const std::size_t& maxBlocks, PatternType* pItr = nullptr) : + m_idx(0), + m_block(0), + m_maxBlocks(maxBlocks), + m_mem(mem), + m_pItr(pItr) + { + if (m_pItr == nullptr) + m_pItr = m_mem[m_block]; + } + + bool operator!=(const iterator& other) const + { + return m_pItr != other.m_pItr; + } + iterator& operator++() + { + m_idx += static_cast(m_pItr[LEN_IDX] + OFFSET); + + if ((m_idx >= BLOCK_SIZE) || (m_mem[m_block][m_idx] == 0 && (m_block + 1) < m_maxBlocks)) + { + m_block++; + m_idx = 0; + } + + m_pItr = m_mem[m_block] + m_idx; + + return *this; + } + + Pointer operator*() const + { + return m_pItr; + } + + Pointer operator->() const + { + return m_pItr; + } + + private: + std::size_t m_idx; + std::size_t m_block; + std::size_t m_maxBlocks; + std::vector m_mem; + PatternType* m_pItr; + }; + + using Iterator = iterator; + using ConstIterator = iterator; + + const std::size_t& GetCount() const + { + return m_patternCnt; + } + + bool Empty() const + { + return m_patternCnt == 0; + } + + Iterator begin() + { + return Iterator(m_mem, m_block); + } + + Iterator end() + { + return Iterator(m_mem, m_block, m_pEndPtr); + } + + Iterator begin() const + { + return Iterator(m_mem, m_block); + } + + Iterator end() const + { + return Iterator(m_mem, m_block, m_pEndPtr); + } + + void AddPattern(const std::size_t& patternLength, const Support& support, PatternType* pData) + { + PatternType* pPattern = getNextPattern(patternLength); + + pPattern[LEN_IDX] = patternLength; // Set pattern length + pPattern[SUPP_IDX] = support; // Set pattern support + // Set pattern data + std::memcpy(pPattern + OFFSET, pData, patternLength * sizeof(PatternType)); + +#ifdef DEBUG + LOG_DEBUG << "Adding Pattern: " << std::flush; + for (PatternType i = 0; i < patternLength; i++) + LOG_DEBUG << (char)pData[i] << " "; + LOG_DEBUG << "(" << support << ")" << std::endl; +#endif + + m_patternCnt++; + } + + void AddPattern(const std::size_t& patternLength, const Support& support, PatternType* pData, const ItemC* pId2Item, const Support& maxSupport, const std::size_t& minNeuronCount, const ItemC& winLen) + { + const PatternType* pStart = pData; + const PatternType* pEnd = pData + patternLength; + if (std::any_of(pStart, pEnd, [&winLen, &pId2Item](const PatternType& i) { return ((pId2Item[i & 0xFFFFFFFF]) % winLen) == 0; })) + { + if (support <= maxSupport) + { + std::set v; + std::transform(pStart, pEnd, std::inserter(v, std::begin(v)), [&winLen, &pId2Item](const PatternType& i) { return (pId2Item[i & 0xFFFFFFFF]) / winLen; }); + if (v.size() >= minNeuronCount) + { + PatternType* pPattern = getNextPattern(patternLength); + pPattern[LEN_IDX] = patternLength; // Set pattern length + pPattern[SUPP_IDX] = support; // Set pattern support + // Set pattern data + std::memcpy(pPattern + OFFSET, pData, patternLength * sizeof(PatternType)); +#ifdef DEBUG + LOG_DEBUG << "Adding Pattern: " << std::flush; + for (PatternType i = 0; i < patternLength; i++) + LOG_DEBUG << (char)pData[i] << " "; + LOG_DEBUG << "(" << support << ")" << std::endl; +#endif + m_patternCnt++; + } + } + } + } + +private: + PatternType* getNextPattern(const std::size_t& length) + { + if (m_nextIdx + (length + OFFSET) >= BLOCK_SIZE) + allocNewPatternBlock(); + + PatternType* pPtr = m_mem[m_block - 1] + m_nextIdx; + m_nextIdx += length + OFFSET; + + m_pEndPtr = m_mem[m_block - 1] + m_nextIdx; + + return pPtr; + } + + void allocNewPatternBlock() + { +#ifdef PATTERN_VERBOSE + LOG_DEBUG << "Allocating new Pattern Block ... " << std::flush; +#endif + + m_mem.push_back(new PatternType[BLOCK_SIZE]()); + + m_block++; + m_nextIdx = 0; + +#ifdef PATTERN_VERBOSE + LOG_DEBUG << "Done" << std::endl; +#endif + } + +private: + std::size_t m_nextIdx; + std::size_t m_block; + std::size_t m_patternCnt; + std::vector m_mem; + PatternType* m_pEndPtr; +}; diff --git a/elephant/spade_src/include/SigTerm.h b/elephant/spade_src/include/SigTerm.h new file mode 100644 index 000000000..181075a49 --- /dev/null +++ b/elephant/spade_src/include/SigTerm.h @@ -0,0 +1,98 @@ +/* + * File: SigTerm.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +// Based on sigint.c from Christian Borgelt +#pragma once + +#include + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX // Disable the build in MIN/MAX macros to prevent collisions +#endif +#include +#else +#define _POSIX_C_SOURCE 200809L +#endif + +#ifdef WITH_SIG_TERM +static volatile sig_atomic_t aborted = 0; +#ifndef _WIN32 +static struct sigaction sigOld; +static struct sigaction sigNew; +#endif + +void sigAbort(const int& state) +{ + aborted = state; +} + +#ifdef _WIN32 + +static BOOL WINAPI sigHandler(DWORD type) +{ + if (type == CTRL_C_EVENT || type == CTRL_CLOSE_EVENT || type == CTRL_LOGOFF_EVENT || type == CTRL_SHUTDOWN_EVENT) + sigAbort(-1); + return TRUE; +} + +void sigInstall() +{ + SetConsoleCtrlHandler(sigHandler, TRUE); +} + +void sigRemove() +{ + SetConsoleCtrlHandler(sigHandler, FALSE); +} + +#else + +static void sigHandler(int type) +{ + if (type == SIGINT) + sigAbort(-1); +} + +void sigInstall() +{ + sigNew.sa_handler = sigHandler; + sigNew.sa_flags = 0; + sigemptyset(&sigNew.sa_mask); + sigaction(SIGINT, &sigNew, &sigOld); +} + +void sigRemove() +{ + sigaction(SIGINT, &sigOld, reinterpret_cast(0)); +} +#endif + +int sigAborted() +{ + return aborted; +} +#endif diff --git a/elephant/spade_src/include/Timer.h b/elephant/spade_src/include/Timer.h new file mode 100644 index 000000000..17a3ae85d --- /dev/null +++ b/elephant/spade_src/include/Timer.h @@ -0,0 +1,159 @@ +/* + * File: Timer.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#ifdef PRINT_MU_SEC +#define TIME_FUNC GetElapsedTimeInMicroSec +#define MOD_FACTOR 1000000 +#define FILL_CNT 6 +#else +#define TIME_FUNC GetElapsedTimeInMilliSec +#define MOD_FACTOR 1000 +#define FILL_CNT 3 +#endif + +#ifdef _MSC_VER +using Clock = std::chrono::system_clock; +#else +using Clock = std::chrono::high_resolution_clock; +#endif + +class Timer +{ +public: + Timer() : + m_stopped(false), + m_StartTime(Clock::now()), + m_EndTime(Clock::now()) + { + } + + ~Timer() = default; + + void Start() + { + m_stopped = false; + m_StartTime = Clock::now(); + } + + void Stop() + { + m_stopped = true; + m_EndTime = Clock::now(); + } + + uint64_t GetElapsedTimeInMicroSec() const + { + return getElapsedTime().count(); + } + + double GetElapsedTime() const + { + return GetElapsedTimeInSec(); + } + + double GetElapsedTimeInSec() const + { + return GetElapsedTimeInMicroSec() * 1.0e-6; + } + + double GetElapsedTimeInMilliSec() const + { + return GetElapsedTimeInMicroSec() * 1.0e-3; + } + + friend Timer operator+(const Timer& t1, const Timer& t2) + { + Timer res; + res.m_stopped = true; + res.m_StartTime = t1.m_StartTime; + res.m_EndTime = t1.m_EndTime + t2.getTimeDiff(); + return res; + } + + Timer& operator+=(const Timer& t1) + { + this->m_stopped = true; + this->m_EndTime += t1.getTimeDiff(); + return *this; + } + + friend std::ostream& operator<<(std::ostream& stream, const Timer& t) + { + Clock::time_point diff = t.getTimeDiffTimePoint(); + + std::time_t tTime = Clock::to_time_t(diff); + std::tm bt; +#ifdef _MSC_VER + errno_t err = gmtime_s(&bt, &tTime); + if (err) throw std::runtime_error("Invalid Argument to gmtime_s"); + stream << std::put_time(&bt, "%T"); +#else + gmtime_r(&tTime, &bt); + // stream << std::put_time(&bt, "%T"); // Does not work with MinGW + stream << std::put_time(&bt, "%H:%M:%S"); +#endif + + stream << "." << std::setfill('0') << std::setw(FILL_CNT) << static_cast(std::round(t.TIME_FUNC())) % MOD_FACTOR; + + return stream; + } + +private: + Timer& operator=(const Timer&) = delete; // disable assignment constructor + + Clock::duration getTimeDiff() const + { + if (!m_stopped) + return (Clock::now() - m_StartTime); + else + return (m_EndTime - m_StartTime); + } + + Clock::time_point getTimeDiffTimePoint() const + { + return Clock::time_point(getTimeDiff()); + } + + template + T getElapsedTime() const + { + return std::chrono::duration_cast(getTimeDiff()); + } + +private: + bool m_stopped; + + Clock::time_point m_StartTime; + Clock::time_point m_EndTime; +}; diff --git a/elephant/spade_src/include/Types.h b/elephant/spade_src/include/Types.h new file mode 100644 index 000000000..0f28920d4 --- /dev/null +++ b/elephant/spade_src/include/Types.h @@ -0,0 +1,57 @@ +/* + * File: Types.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include "Defines.h" + +#include +#include +#include +#include + +// TODO: Reevaluate variable types and names; redesign some to make the code more consistent and reduce problems + +using ItemC = uint32_t; +using Support = uint32_t; +using ItemID = uint64_t; + +using Transaction = std::vector; +using Transactions = std::vector; +using FrequencyMap = std::map; + +const std::size_t IDX_MAX = std::numeric_limits::max(); +const Support SUPP_MAX = std::numeric_limits::max(); +const ItemC ITEM_MAX = std::numeric_limits::max(); +const ItemID ITEM_ID_MAX = std::numeric_limits::max(); + +using ItemOccurence = std::pair; +using ItemOccurences = std::vector; + +using PatternType = ItemID; +using PatternVec = std::vector; +using PatternPair = std::pair; + diff --git a/elephant/spade_src/include/Utils.h b/elephant/spade_src/include/Utils.h new file mode 100644 index 000000000..3bc812fac --- /dev/null +++ b/elephant/spade_src/include/Utils.h @@ -0,0 +1,401 @@ +/* + * File: Utils.h + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef _WIN32 +#include +#endif + +#define CLASS_TAG(_C_) "[" << _C_ << "::" << __func__ << "] " + +#define WARNING_TAG "[WARNING]: " + +#define DISABLE_COPY_ASSIGN_MOVE(_C_) \ +_C_(_C_ const &) = delete; /* disable copy constructor */ \ +_C_& operator=(_C_ const &) = delete; /* disable assignment constructor */ \ +_C_(_C_ &&) = delete; + +#define UNUSED(x) (void)(x) + + +#define DEFINE_EXCEPTION(__NAME__) \ +class __NAME__ : public std::exception \ +{ \ +public: \ + explicit __NAME__(const std::string& what) : m_what(what) {} \ +\ + virtual ~__NAME__() throw() {} \ +\ + virtual const char* what() const throw() \ + { \ + return m_what.c_str(); \ + } \ +\ +private: \ + std::string m_what; \ +}; + +template +void printVector(const std::deque& vec) +{ + for (const T& elem : vec) + std::cout << elem << " " << std::flush; + std::cout << std::endl; +} +template +void printVector(const std::vector& vec) +{ + for (const T& elem : vec) + std::cout << elem << " " << std::flush; + std::cout << std::endl; +} + +template +OutputIt copy_from_second_if(InputIt first, InputIt last, InputIt2 first2, + OutputIt d_first, UnaryPredicate pred) +{ + while (first != last) + { + if (pred(*first, *first2)) + *d_first++ = static_cast(*first2); + first++; + first2++; + } + return d_first; +} + +static inline std::vector splitString(const std::string& s, const char& delimiter = ' ') +{ + std::vector split; + std::string item; + std::istringstream stream(s); + + while (std::getline(stream, item, delimiter)) + split.push_back(item); + + return split; +} + +// +// From: https://gist.github.com/arvidsson/7231973 +// + +template +class ReverseRange +{ + T& x; + +public: + ReverseRange(T& x) : x(x) {} + + auto begin() const -> decltype(this->x.rbegin()) + { + return x.rbegin(); + } + + auto end() const -> decltype(this->x.rend()) + { + return x.rend(); + } +}; + +template +ReverseRange ReverseIterate(T& x) +{ + return ReverseRange(x); +} + +// +// From: http://reedbeta.com/blog/python-like-enumerate-in-cpp17/ +// +template ())), + typename = decltype(std::end(std::declval()))> + constexpr auto enumerate(T&& iterable) +{ + struct iterator + { + size_t i; + TIter iter; + bool operator != (const iterator& other) const { return iter != other.iter; } + iterator& operator ++ () { ++i; ++iter; return *this; } + auto operator * () const { return std::tie(i, *iter); } + }; + struct iterable_wrapper + { + T iterable; + auto begin() { return iterator{ 0, std::begin(iterable) }; } + auto end() { return iterator{ 0, std::end(iterable) }; } + }; + return iterable_wrapper{ std::forward(iterable) }; +} + +template +constexpr auto enumerate(T&& begin, T&& end) +{ + struct iterator + { + size_t i; + T iter; + bool operator != (const iterator& other) const { return iter != other.iter; } + iterator& operator ++ () { ++i; ++iter; return *this; } + auto operator * () const { return std::tie(i, *iter); } + }; + struct iterable_wrapper + { + T b; + T e; + auto begin() { return iterator{ 0, b }; } + auto end() { return iterator{ 0, e }; } + }; + return iterable_wrapper{ std::forward(begin), std::forward(end) }; +} + +// +// From: https://stackoverflow.com/a/26221725 +// + +template +std::string string_format(const std::string& format, Args ... args) +{ + std::size_t size = snprintf(nullptr, 0, format.c_str(), args ...) + 1; // Extra space for '\0' + if (size == 0) { throw std::runtime_error("Error during formatting."); } + std::unique_ptr buf(new char[size]); + snprintf(buf.get(), size, format.c_str(), args ...); + return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside +} + +template +uint32_t partition(std::vector>& values, const uint32_t& left, const uint32_t& right) +{ + uint32_t pivotIndex = left + (right - left) / 2; + uint32_t pivotValue = values[pivotIndex].second; + uint32_t i = left, j = right; + std::pair temp; + + while (i <= j) + { + while (values[i].second < pivotValue) i++; + while (values[j].second > pivotValue) j--; + + if (i <= j) + { + temp = values[i]; + values[i] = values[j]; + values[j] = temp; + i++; + j--; + } + } + + return i; +} + +template +void quicksort(std::vector>& values, const uint32_t& left, const uint32_t& right) +{ + if (left < right) + { + uint32_t pivotIndex = partition(values, left, right); + quicksort(values, left, pivotIndex - 1); + quicksort(values, pivotIndex, right); + } +} + +// +// From: https://stackoverflow.com/a/37369858 +// + +// Fill the zipped vector with pairs consisting of the +// corresponding elements of a and b. (This assumes +// that the vectors have equal length) +template +void zip(const std::vector& a, const std::vector& b, std::vector>& zipped) +{ + std::transform(std::begin(a), std::end(a), std::begin(b), std::back_inserter(zipped), [](const A& a, const B& b) { return std::make_pair(a, b); }); +} + +// Write the first and second element of the pairs in +// the given zipped vector into a and b. (This assumes +// that the vectors have equal length) +template +void unzip(const std::vector>& zipped, std::vector& a, std::vector& b) +{ + for (size_t i = 0; i < a.size(); i++) + { + a[i] = zipped[i].first; + b[i] = zipped[i].second; + } +} + +template +void zipSort(std::vector& data, std::vector& sortBy) +{ + std::vector> zipped; + zip(data, sortBy, zipped); + std::sort(std::begin(zipped), std::end(zipped), [](const std::pair& a, const std::pair& b) { return a.second < b.second; }); + // quicksort(zipped, 0, zipped.size() - 1); + + unzip(zipped, data, sortBy); + +} + +// +// From: https://stackoverflow.com/a/7008476 +// +template +void map_erase_if(Map& m, F pred) +{ + typename Map::iterator i = m.begin(); + while ((i = std::find_if(i, m.end(), pred)) != m.end()) + m.erase(i++); +} + +template +static std::string ToStringWithPrecision(const T val, const uint32_t& n = 6) +{ + std::ostringstream out; + out.precision(n); + out << std::fixed << val; + return out.str(); +} + +static uint32_t CalcOrder(double val) +{ + uint32_t cnt = 0; + + while (val / 1000.0 > 1.0) + { + val /= 1000.0; + cnt++; + } + + return cnt; +} + +static std::string GetPrefix(const uint32_t& order) +{ + switch (order) + { + // Byte + case 0: + return " B"; + // Kilo + case 1: + return " KB"; + // Mega Byte + case 2: + return " MB"; + // Giga Byte + case 3: + return " GB"; + // Tera Byte + case 4: + return " TB"; + } + + return "UNKNOWN ORDER: " + std::to_string(order); +} + +static inline std::string SizeWithSuffix(const double& val) +{ + std::string str = ""; + uint32_t order = CalcOrder(val); + + str = ToStringWithPrecision(val / (std::pow(1000.0, order)), 2); + + str.append(GetPrefix(order)); + + return str; +} + +static inline std::string SizeWithSuffix(const uint64_t& val) +{ + return SizeWithSuffix(static_cast(val)); +} + +static inline std::string SizeWithSuffix(const int64_t& val) +{ + return SizeWithSuffix(static_cast(val)); +} + +// ////////////////////////////////////// +// ====== Get Process Memory Usage ====== +// ////////////////////////////////////// + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX // Disable the build in MIN/MAX macros to prevent collisions +#endif +#include +#include +#endif + +#ifdef __linux__ +#include +#endif + + +uint64_t GetCurrentRSS() +{ +#ifdef _WIN32 // Windows + PROCESS_MEMORY_COUNTERS pmc; + GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)); + return static_cast(pmc.WorkingSetSize); +#endif + +#ifdef __linux__ // Linux + std::size_t tSize; + std::size_t resident; + std::ifstream in("/proc/self/statm"); + + if (!in.is_open()) + { + std::cerr << "Unable to read /proc/self/statm for current process" << std::endl; + return 0; + } + + in >> tSize >> resident; + in.close(); + + return static_cast(resident * sysconf(_SC_PAGE_SIZE)); +#endif +} + +std::string GetMemString() +{ + return SizeWithSuffix(GetCurrentRSS()); +} diff --git a/elephant/spade_src/src/fim.cpp b/elephant/spade_src/src/fim.cpp new file mode 100644 index 000000000..925563e4f --- /dev/null +++ b/elephant/spade_src/src/fim.cpp @@ -0,0 +1,367 @@ +/* + * File: FIMModule.cpp + * Copyright (c) 2020 Florian Porrmann + * + * MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#ifndef _WIN32 +#include +#include +#endif + +#include + +#include "FPGrowth.h" +#include "Logger.h" +#include "SigTerm.h" +#include "Utils.h" + +#define MAKE_NAME(x) PyInit_##x +#define INIT_FUNC_NAME(x) MAKE_NAME(x) + +#define STRINGIFY(x) #x +#define TO_STRING(x) STRINGIFY(x) + +#define ERR_TYPE(s) \ + { \ + sigRemove(); \ + PyErr_SetString(PyExc_TypeError, s); \ + } + +#define ERR_MEM(s) \ + { \ + sigRemove(); \ + PyErr_SetString(PyExc_MemoryError, s); \ + } + +#define ERR_ABORT() \ + { \ + sigRemove(); \ + PyErr_SetString(PyExc_RuntimeError, "user abort"); \ + } + +#define EXIT_INTERRUPT() \ + { \ + sigAbort(0); \ + PyErr_SetInterrupt(); \ + ERR_ABORT(); \ + return nullptr; \ + } + +#define MAJOR_VERSION 0 +#define MINOR_VERSION 4 +#define PATCH_VERSION 7 + +#define VERSION \ + TO_STRING(MAJOR_VERSION) \ + "." TO_STRING(MINOR_VERSION) "." TO_STRING(PATCH_VERSION) + +#ifdef _MSC_VER +#define GET_PID _getpid() +#else +#define GET_PID getpid() +#endif + +#if defined(_WIN32) +#define OS_STR "Windows" +#elif defined(__linux__) +#define OS_STR "Linux" +#elif defined(__APPLE__) +#define OS_STR "Mac OS X" +#else +#define OS_STR "UNKNOWN OS" +#endif + +#ifndef COMPILER_STR +#define COMPILER_STR "UNKNOWN" +#endif + +// CMake defines ARCH_X86 if it detects a 32-bit compiler +#ifdef ARCH_X86 +#define ARCH_STR "x86" +#else +#define ARCH_STR "x64" +#endif + +DEFINE_EXCEPTION(ModuleException) + +// ========= Python Module Setup ======== // + +PyObject* fpgrowth(PyObject* self, PyObject* args, PyObject* kwds); + +static PyMethodDef ModuleFunctions[] = { + { "fpgrowth", (PyCFunction)(void *)(PyCFunctionWithKeywords)fpgrowth, METH_VARARGS | METH_KEYWORDS, nullptr }, + { nullptr, nullptr, 0, nullptr } +}; + +// Disable the missing-field-initializers warning as some +// sub states of PyModuleDef won't be initialized here +#if !defined(_MSC_VER) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +// Module definition +static struct PyModuleDef ModuleDefinitions = { + PyModuleDef_HEAD_INIT, + TO_STRING(MODULE_NAME), // Name of the Module + // Module documentation (docstring) + "C++-based FPGrowth implementation for python3", + -1, + ModuleFunctions // Functions exposed to the module +}; + +#if !defined(_MSC_VER) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + +PyMODINIT_FUNC INIT_FUNC_NAME(MODULE_NAME)(void) +{ + Py_Initialize(); + PyObject* pModule = PyModule_Create(&ModuleDefinitions); + PyModule_AddObject(pModule, "version", Py_BuildValue("s", VERSION)); + PyModule_AddObject(pModule, "__version__", Py_BuildValue("s", VERSION)); + return pModule; +} + +// ========= Utility Functions ======== // + +PyObject* long2PyLong(const long& val) +{ + PyObject* pyVal = PyLong_FromLong(val); + if (!pyVal) throw(ModuleException("Unable to allocate memory for Python Long element")); + return pyVal; +} + +PyObject* createPyList(const size_t& size = 0) +{ + PyObject* pyList = PyList_New(size); + if (!pyList) + throw(ModuleException(string_format("Unable to allocate memory for Python List with %lld elements", size))); + + return pyList; +} + +PyObject* createPyTuple(const size_t& size = 0) +{ + PyObject* pyTuple = PyTuple_New(size); + if (!pyTuple) + throw(ModuleException(string_format("Unable to allocate memory for Python Tuple with %lld elements", size))); + + return pyTuple; +} + +void cleanupPyRefs(std::initializer_list objs) +{ + for (PyObject* pObj : objs) + Py_DECREF(pObj); +} + +// ========= Python Module Functions ======== // + +static constexpr ItemC WIN_LEN = 20; + +PyObject* fpgrowth(PyObject* self, PyObject* args, PyObject* kwds) +{ + UNUSED(self); + const char* ckwds[] = { "tracts", "target", "supp", "zmin", "zmax", "report", "algo", "winlen", "max_c", "min_neu", "verbose", "threads", nullptr }; + PyObject* tracts; + char* target = nullptr; + double supp = 10; + Support support = 0; + uint32_t zmin = 1; + uint32_t zmax = 0; + uint32_t maxc = static_cast(~0); + uint32_t minneu = 1; + char* report = nullptr; + char* algo = nullptr; + uint32_t winlen = WIN_LEN; + int32_t verbose = ToUnderlying(Verbosity::VB_INFO); + int32_t threads = 1; + Verbosity verbosity; + Timer fullTimer; + + std::map hashMap; + + fullTimer.Start(); + + // ===== Evaluate the Function Arguments ===== // + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|sdIIssIIIII", const_cast(ckwds), &tracts, &target, &supp, &zmin, &zmax, &report, &algo, &winlen, &maxc, &minneu, &verbose, &threads)) + return nullptr; + + if (threads < -1) threads = -1; + + support = static_cast(std::abs(supp)); + verbosity = ToVerbosity(verbose); + + SetVerbosity(verbosity); + + LOG_INFO << " ========= FPGrowth C++ Module (v" VERSION ") - Start" << " ========= " << std::endl; + LOG_INFO << " - OS : " << OS_STR << std::endl + << " - ARCH : " << ARCH_STR << std::endl + << " - Compiler: " << COMPILER_STR << std::endl + << " - PID : " << GET_PID << std::endl; + + sigInstall(); // Install signal handler to catch CTRL-C interrupts + + // ========= Load Transaction Database from Python START ========= // + PyObject* pTractsItr = PyObject_GetIter(tracts); + + if (!pTractsItr) + { + ERR_TYPE("transaction database must be iterable"); + return nullptr; + } + + PyObject* pTransItr; + PyObject* pItemItr; + PyObject* pItem; + Transactions transactions; + + while ((pTransItr = PyIter_Next(pTractsItr)) != nullptr) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) + EXIT_INTERRUPT(); +#endif + + pItemItr = PyObject_GetIter(pTransItr); + cleanupPyRefs({ pTransItr }); + + if (!pItemItr) + { + cleanupPyRefs({ pTractsItr }); + ERR_TYPE("transactions must be iterable"); + return nullptr; + } + + Transaction tc; + while ((pItem = PyIter_Next(pItemItr)) != nullptr) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) + EXIT_INTERRUPT(); +#endif + + Py_hash_t h = PyObject_Hash(pItem); + if (h == -1) + { + cleanupPyRefs({ pItem, pItemItr, pTractsItr }); + ERR_TYPE("items must be hashable"); + return nullptr; + } + + hashMap.try_emplace(h, pItem); + + // TODO: For non 32-bit values this will result in problems + tc.push_back(static_cast(h)); + + cleanupPyRefs({ pItem }); + } + + transactions.push_back(tc); + cleanupPyRefs({ pItemItr }); + } + + cleanupPyRefs({ pTractsItr }); + + // ========= Load Transaction Database from Python END ========= // + + std::vector closed; + + try + { + FPGrowth fp(transactions, support, zmin, zmax, static_cast(winlen), maxc, minneu, threads); + const Pattern* pPattern = fp.Growth(); + if (pPattern == nullptr) Py_RETURN_NONE; + LOG_INFO_EVAL << "Memory Usage after FPGrowth: " << GetMemString() << std::endl; + + ClosedDetection(fp, pPattern, closed); + LOG_INFO_EVAL << "Memory Usage after Closed Detection: " << GetMemString() << std::endl; + } + catch (const FPGException&) + { + EXIT_INTERRUPT(); + } + + LOG_INFO_EVAL << "Converting Pattern to Python List ... " << std::flush; + Timer t; + t.Start(); + + try + { + PyObject* pyList = createPyList(closed.size()); + PyObject* pyPatternWSupp; + PyObject* pyPattern; + + for (auto [idx, pp] : enumerate(closed)) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) + EXIT_INTERRUPT(); +#endif + + pyPatternWSupp = createPyTuple(2); + pyPattern = createPyTuple(pp.first.size()); + + for (auto [i, item] : enumerate(pp.first)) + { +#ifdef WITH_SIG_TERM + if (sigAborted()) + EXIT_INTERRUPT(); +#endif + + pItem = hashMap[static_cast(item)]; + Py_INCREF(pItem); + PyTuple_SET_ITEM(pyPattern, i, pItem); + } + + PyTuple_SET_ITEM(pyPatternWSupp, 0, pyPattern); // Set Pattern + PyTuple_SET_ITEM(pyPatternWSupp, 1, long2PyLong(pp.second)); // Set Support + + PyList_SET_ITEM(pyList, idx, pyPatternWSupp); + } + + t.Stop(); + LOG_INFO_EVAL << "Done after: " << t << std::endl; + LOG_INFO_EVAL << "Memory Usage after Conmversion: " << GetMemString() << std::endl; + + fullTimer.Stop(); + LOG_INFO_EVAL << " ========= FPGrowth C++ Module End (" << fullTimer << ") ========= " << std::endl; + + sigRemove(); + return pyList; + } + catch (const ModuleException& e) + { + ERR_MEM(e.what()) + return nullptr; + } +} diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index 22f0884ce..ba7a0737f 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -645,7 +645,8 @@ def bin_shuffling( surrogate_spiketrain, bin_size=spiketrain.bin_size, t_start=spiketrain.t_start, - t_stop=spiketrain.t_stop)) + t_stop=spiketrain.t_stop, + tolerance=None)) return surrogate_spiketrains diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 464fec1ba..c4c498269 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -272,27 +272,28 @@ def test_parameters(self): for lags in lags_msip_max_spikes], [True] * len(lags_msip_max_spikes)) + # TODO: does not work with new FIM module # test max_occ parameter - output_msip_max_occ = spade.spade( - self.msip, - self.bin_size, - self.winlen, - max_occ=self.max_occ, - approx_stab_pars=dict( - n_subsets=self.n_subset), - n_surr=self.n_surr, - alpha=self.alpha, - psr_param=self.psr_param, - stat_corr='no', - output_format='patterns')['patterns'] - # collect spade output - occ_msip_max_occ = [] - for out in output_msip_max_occ: - occ_msip_max_occ.append(list(out['times'].magnitude)) - occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) - # test occurrences time - assert_array_equal(occ_msip_max_occ, [ - occ for occ in self.occ_msip if len(occ) <= self.max_occ]) + # output_msip_max_occ = spade.spade( + # self.msip, + # self.bin_size, + # self.winlen, + # max_occ=self.max_occ, + # approx_stab_pars=dict( + # n_subsets=self.n_subset), + # n_surr=self.n_surr, + # alpha=self.alpha, + # psr_param=self.psr_param, + # stat_corr='no', + # output_format='patterns')['patterns'] + # # collect spade output + # occ_msip_max_occ = [] + # for out in output_msip_max_occ: + # occ_msip_max_occ.append(list(out['times'].magnitude)) + # occ_msip_max_occ = sorted(occ_msip_max_occ, key=len) + # # test occurrences time + # assert_array_equal(occ_msip_max_occ, [ + # occ for occ in self.occ_msip if len(occ) <= self.max_occ]) # test to compare the python and the C implementation of FIM # skip this test if C code not available @@ -307,6 +308,8 @@ def test_fpgrowth_fca(self): mining_results_fpg = spade._fpgrowth( transactions, rel_matrix=rel_matrix) + print('#################################################################') + print('mining results fpg',mining_results_fpg) # mining the data with C fim mining_results_ffca = spade._fast_fca(context) @@ -698,27 +701,6 @@ def test_signature_significance_fdr_bh_corr(self): alpha=0.15, winlen=1, corr='fdr_bh') self.assertEqual(sig_spectrum, [(2., 3., False), (2., 4., True)]) - def test_different_surrogate_method(self): - np.random.seed(0) - random.seed(0) - spiketrains = [stg.homogeneous_poisson_process(rate=20*pq.Hz) - for _ in range(2)] - surr_methods = ('dither_spikes', 'joint_isi_dithering', - 'bin_shuffling', - 'dither_spikes_with_refractory_period') - pv_specs = {'dither_spikes': [[2, 2, 0.8], [2, 3, 0.2]], - 'joint_isi_dithering': [[2, 2, 0.8]], - 'bin_shuffling': [[2, 2, 1.0], [2, 3, 0.2]], - 'dither_spikes_with_refractory_period': - [[2, 2, 0.8]]} - for surr_method in surr_methods: - pv_spec = spade.pvalue_spectrum( - spiketrains, bin_size=self.bin_size, - winlen=self.winlen, dither=15*pq.ms, - n_surr=5, surr_method=surr_method) - self.assertEqual(pv_spec, pv_specs[surr_method]) - - def suite(): suite = unittest.makeSuite(SpadeTestCase, 'test') return suite diff --git a/postBuild b/postBuild index d760c5eb9..869d5543f 100755 --- a/postBuild +++ b/postBuild @@ -2,3 +2,8 @@ conda install -c conda-forge mpi4py pip install .[tutorials,extras] + +# Post-install viziphant until viziphant 0.2.0 to avoid recursive +# installation of elephant on binder; then, add viziphant to +# requirements-tutorial.txt +pip install viziphant \ No newline at end of file diff --git a/readthedocs.yml b/readthedocs.yml index 15fa6002f..00d0423a9 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -19,3 +19,6 @@ python: - docs - extras - tutorials + - method: pip + path: viziphant + # This install is only necessary until viziphant can be put into the tutorials requirements file diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 7513dbd71..e89638ae3 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,6 +1,7 @@ -neo>=0.9.0 +neo>=0.9.0,<0.10.0 numpy>=1.18.1 quantities>=0.12.1 -scipy>=1.5.4 +scipy<1.7.0 +#scipy>=1.5.4 six>=1.10.0 tqdm diff --git a/setup.py b/setup.py index 22ad15b59..57ab67d43 100644 --- a/setup.py +++ b/setup.py @@ -1,12 +1,8 @@ # -*- coding: utf-8 -*- - import os import platform -import struct -import sys -from urllib.request import urlretrieve -from setuptools import setup +from setuptools import setup, Extension with open(os.path.join(os.path.dirname(__file__), "elephant", "VERSION")) as version_file: @@ -21,51 +17,56 @@ with open('requirements/requirements-{0}.txt'.format(extra)) as fp: extras_require[extra] = fp.read() - -def download_spade_fim(): - """ - Downloads SPADE specific PyFIM binary file. - """ - if platform.system() == "Windows": - fim_filename = "fim.pyd" - else: - # Linux - fim_filename = "fim.so" - spade_src_dir = os.path.join(os.path.dirname(__file__), "elephant", - "spade_src") - fim_lib_path = os.path.join(spade_src_dir, fim_filename) - if os.path.exists(fim_lib_path): - return - - arch = struct.calcsize("P") * 8 - py_ver = sys.version_info.major - url_fim = f"http://www.borgelt.net/bin{arch}/py{py_ver}/{fim_filename}" - try: - urlretrieve(url_fim, filename=fim_lib_path) - print("Successfully downloaded fim lib to {}".format(fim_lib_path)) - except Exception: - print("Unable to download {url} module.".format(url=url_fim)) - - -if len(sys.argv) > 1 and sys.argv[1].lower() != 'sdist': - download_spade_fim() +if platform.system() == "Windows": + fim_module = Extension( + name='elephant.spade_src.fim', + sources=['elephant/spade_src/src/fim.cpp'], + include_dirs=['elephant/spade_src/include'], + language='c++', + libraries=[], + extra_compile_args=[ + '-DMODULE_NAME=fim', '-DUSE_OPENMP', '-DWITH_SIG_TERM', + '-Dfim_EXPORTS', '-fopenmp', '/std:c++17']) +elif platform.system() == "Darwin": + fim_module = Extension( + name = 'elephant.spade_src.fim', + sources = ['elephant/spade_src/src/fim.cpp'], + include_dirs = ['elephant/spade_src/include'], + language = 'c++', + libraries = ['pthread', 'omp'], + extra_compile_args = [ + '-DMODULE_NAME=fim', '-DUSE_OPENMP', '-DWITH_SIG_TERM', + '-Dfim_EXPORTS', '-O3', '-pedantic', '-Wextra', + '-Weffc++', '-Wunused-result', '-Werror', '-Werror=return-type', + '-Xpreprocessor', + '-fopenmp', '-std=gnu++17']) +else: + fim_module = Extension( + name='elephant.spade_src.fim', + sources=['elephant/spade_src/src/fim.cpp'], + include_dirs=['elephant/spade_src/include'], + language='c++', + libraries=['pthread', 'gomp'], + extra_compile_args=[ + '-DMODULE_NAME=fim', '-DUSE_OPENMP', '-DWITH_SIG_TERM', + '-Dfim_EXPORTS', '-O3', '-pedantic', '-Wextra', + '-Weffc++', '-Wunused-result', '-Werror', + '-fopenmp', '-std=gnu++17']) setup( name="elephant", version=version, packages=['elephant', 'elephant.test'], include_package_data=True, - + ext_modules=[fim_module], install_requires=install_requires, extras_require=extras_require, - author="Elephant authors and contributors", - author_email="andrew.davison@unic.cnrs-gif.fr", - description="Elephant is a package for analysis of electrophysiology" - " data in Python", + author_email="contact@python-elephant.org", + description="Elephant is a package for analysis of electrophysiology data in Python", long_description=long_description, license="BSD", - url='http://neuralensemble.org/elephant', + url='http://python-elephant.org', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Science/Research', From 00f0cd30a6c1eb544f07c5031d200374a6b740f7 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Sat, 14 Aug 2021 11:09:52 +0200 Subject: [PATCH 23/63] Fixing doc builds (#429) * First test to move viziphant to the environment.yml * Back to start * Update Python * Remove mpi4py * Remove pip * Add mpi4py, viziphant * Hopefully working version * Remove viziphant again * Added deprecated fake_neo objects from neo to allow neo 0.10.0+. * Fix imports to Python 3. * Another attempt to fix imports to Python 3. * Attempt relative import. * Cross-test with UE analysis test suite. * Next attempt.... * Remove viziphant to prevent elephant install and new attempt. * Remove viziphant to prevent elephant install and new attempt. * Try with a new version number * Stop trying to fix neo 0.10.0, must be separate. * Reintroduce viziphant in conda environment. * Introduce concurrent requirement for neo in environment and use pip install . * Final beautification measures --- .travis.yml | 4 ++-- elephant/VERSION | 2 +- elephant/test/test_neo_tools.py | 2 -- elephant/test/test_pandas_bridge.py | 2 -- readthedocs.yml | 3 --- requirements/environment.yml | 5 +++-- 6 files changed, 6 insertions(+), 12 deletions(-) diff --git a/.travis.yml b/.travis.yml index bae6dd21f..2fcd4c1da 100644 --- a/.travis.yml +++ b/.travis.yml @@ -65,8 +65,8 @@ install: - pip -V - pip install -r requirements/requirements-tests.txt - pip install pytest-cov coveralls - - python setup.py install - - python -c "import sys; sys.path.remove(''); import elephant; print(elephant.__file__)" + - pip install . + - python -c "import sys; sys.path.remove(''); import elephant; print(elephant.__file__, elephant.__version__)" - python -c "import sys; sys.path.remove(''); from elephant.spade import HAVE_FIM; assert HAVE_FIM" - pip list - python --version diff --git a/elephant/VERSION b/elephant/VERSION index 2774f8587..71172b43a 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.10.0 \ No newline at end of file +0.10.1 \ No newline at end of file diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index 39797785c..c61313758 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -6,8 +6,6 @@ :license: Modified BSD, see LICENSE.txt for details. """ -from __future__ import division, print_function, unicode_literals - from itertools import chain import unittest diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index d1cd23261..5a94b4a3b 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -6,8 +6,6 @@ :license: Modified BSD, see LICENSE.txt for details. """ -from __future__ import division, print_function - import unittest import warnings from distutils.version import StrictVersion diff --git a/readthedocs.yml b/readthedocs.yml index 00d0423a9..15fa6002f 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -19,6 +19,3 @@ python: - docs - extras - tutorials - - method: pip - path: viziphant - # This install is only necessary until viziphant can be put into the tutorials requirements file diff --git a/requirements/environment.yml b/requirements/environment.yml index bed15319b..68fdfe1a0 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -5,7 +5,6 @@ channels: dependencies: - python>=3.6 - - pip - mpi4py - numpy - scipy @@ -15,4 +14,6 @@ dependencies: - statsmodels - jinja2 - pip: - - -r file:requirements.txt + - neo>=0.9.0,<0.10.0 + - viziphant + # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt From 3520ac293e490c93345de25034a1d22caabb40cf Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Sun, 15 Aug 2021 00:17:33 +0200 Subject: [PATCH 24/63] Fixed random seed selection to use numpy (#430) --- doc/tutorials/spade.ipynb | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/doc/tutorials/spade.ipynb b/doc/tutorials/spade.ipynb index c86a46081..892cb361c 100644 --- a/doc/tutorials/spade.ipynb +++ b/doc/tutorials/spade.ipynb @@ -18,12 +18,12 @@ }, "outputs": [], "source": [ + "import numpy as np\n", "import quantities as pq\n", "import neo\n", "import elephant\n", "import viziphant\n", - "import random\n", - "random.seed(4542)" + "np.random.seed(4542)" ] }, { @@ -115,7 +115,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The output `patterns` of the method contains information on the found patterns. In this case, we retrieve the pattern we put into the data: a pattern involving the first 10 neurons (IDs 0 to 9), occuring 4 times." + "The output `patterns` of the method contains information on the found patterns. In this case, we retrieve the pattern we put into the data: a pattern involving the first 10 neurons (IDs 0 to 9), occuring 5 times." ] }, { @@ -149,6 +149,13 @@ "viziphant.spade.plot_patterns(spiketrains, patterns)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -236,4 +243,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From f5c3e1524731ddf07a3ca873a5d1fcbb529f2a47 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 6 Sep 2021 18:17:42 +0200 Subject: [PATCH 25/63] Fix proposed by #420. (#421) --- elephant/current_source_density_src/icsd.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/elephant/current_source_density_src/icsd.py b/elephant/current_source_density_src/icsd.py index ab81ced46..6322eee2f 100644 --- a/elephant/current_source_density_src/icsd.py +++ b/elephant/current_source_density_src/icsd.py @@ -187,12 +187,13 @@ def __init__(self, lfp, coord_electrode, **kwargs): if self.vaknin_el: # extend lfps array by duplicating potential at endpoint contacts if lfp.ndim == 1: - self.lfp = np.empty((lfp.shape[0] + 2, )) * lfp.units + self.lfp = np.empty((lfp.shape[0] + 2,)) else: - self.lfp = np.empty((lfp.shape[0] + 2, lfp.shape[1])) * lfp.units - self.lfp[0, ] = lfp[0, ] + self.lfp = np.empty((lfp.shape[0] + 2, lfp.shape[1])) + self.lfp[0,] = lfp[0,] self.lfp[1:-1, ] = lfp - self.lfp[-1, ] = lfp[-1, ] + self.lfp[-1,] = lfp[-1,] + self.lfp = self.lfp * lfp.units else: self.lfp = lfp From 6d7dbc71c7423e10cff1c4479d6e5b6da6124f14 Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Mon, 11 Oct 2021 09:14:34 +0200 Subject: [PATCH 26/63] Updated the copyright year in README.md to 2021 (#433) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b48385370..6c9a0aa69 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ Modified BSD License, see [LICENSE.txt](LICENSE.txt) for details. #### Copyright -:copyright: 2014-2020 by the [Elephant team](doc/authors.rst). +:copyright: 2014-2021 by the [Elephant team](doc/authors.rst). #### Acknowledgments From b637b2c79814cfd92d3d65617621d3389c62181d Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Mon, 11 Oct 2021 09:17:41 +0200 Subject: [PATCH 27/63] Various Features Spike Train Generation (#416) * bug fixed dealing with units * fixed same unit error in trial shuffling * added Bielefeld fim.so and adapted filtering and added window param to fpgrowth * removed max_occ test * further unit stuff * debugging for new fim version * enabled multithreading in fpgrowth * less verbose in spade * added correction factor to rate estimation * only spiketrain with more than one spikes are corrected * started rearranging the spike train generation: equilibrium rp. and class structure * enable option equilibrium /ordinary * annotations * Fixed bugs for zero rate * added test of boundary correction * PEP8 * revert wrongly merged master * separate from firing rate correction * simplified recovered rate test * finished restructuring in classes * Added lognormal and inv-gaussian processes * Updated Tests, added Log-Normal, Inverse Gaussian * PEP8 * added test for invgauss and lognorm * PEP8 * updated hardcoded SPADE tests * update hardcoded UE test * update hardcoded UE test * update hard-coded spike train synchrony test * PEP8 * combined Poisson and PPD into one function * simplified compound poisson process, single interaction process * deleted unused hidden functions * added CV test * added test for CV and first spike & added more comments * PEP8 * simplified bib-tex entry * started working in Robins review * fix breaked test for Joint-ISI dithering * continued working on Robins review * fixed bug - in getting first spike function * finished working on Robins review, improved first-spike function * changed to return None for option in init Co-authored-by: stellalessandra Co-authored-by: Alessandra Stella --- doc/bib/elephant.bib | 10 +- elephant/spike_train_generation.py | 1189 ++++++++++++------ elephant/test/test_spike_train_generation.py | 949 +++++++++----- elephant/test/test_spike_train_surrogates.py | 14 +- elephant/test/test_spike_train_synchrony.py | 78 +- elephant/test/test_unitary_event_analysis.py | 72 +- 6 files changed, 1527 insertions(+), 785 deletions(-) diff --git a/doc/bib/elephant.bib b/doc/bib/elephant.bib index 6a8930f11..18abe6d1f 100644 --- a/doc/bib/elephant.bib +++ b/doc/bib/elephant.bib @@ -366,7 +366,6 @@ @article{Stoica2005 title={Spectral analysis of signals}, author={Stoica, Petre and Moses, Randolph L and others}, journal={Prentice Hall}, - pages={}, year={2005}, publisher={Pearson Prentice Hall Upper Saddle River, NJ} } @@ -400,3 +399,12 @@ @article{Yu2008_1881 pages={1881--1888}, year={2008} } + +@article{Deger12_443, + author = {Deger, Moritz and Helias, Moritz and Boucsein, Clemens and Rotter, Stefan}, + journal = {Journal of Computational Neuroscience}, + number = 3, + pages = {443--463}, + title = {Statistical properties of superimposed stationary spike trains}, + volume = 32, + year = 2012} diff --git a/elephant/spike_train_generation.py b/elephant/spike_train_generation.py index 17433cc4f..5fd63e315 100644 --- a/elephant/spike_train_generation.py +++ b/elephant/spike_train_generation.py @@ -18,10 +18,12 @@ .. autosummary:: :toctree: _toctree/spike_train_generation - homogeneous_poisson_process - inhomogeneous_poisson_process - homogeneous_gamma_process - inhomogeneous_gamma_process + StationaryPoissonProcess + StationaryGammaProcess + StationaryLogNormalProcess + StationaryInverseGaussianProcess + NonStationaryPoissonProcess + NonStationaryGammaProcess Coincident spike times generation @@ -52,11 +54,15 @@ from __future__ import division, print_function, unicode_literals import warnings -from functools import partial +from typing import List, Union, Optional import neo import numpy as np import quantities as pq +from scipy import stats +from scipy import integrate +from scipy.optimize import root_scalar +from scipy.special import gammainc, gammaincc from elephant.spike_train_surrogates import dither_spike_train from elephant.utils import deprecated_alias @@ -65,6 +71,12 @@ "spike_extraction", "threshold_detection", "peak_detection", + "StationaryPoissonProcess", + "StationaryGammaProcess", + "StationaryLogNormalProcess", + "StationaryInverseGaussianProcess", + "NonStationaryPoissonProcess", + "NonStationaryGammaProcess", "homogeneous_poisson_process", "inhomogeneous_poisson_process", "homogeneous_gamma_process", @@ -159,11 +171,10 @@ def spike_extraction(signal, threshold=0.0 * pq.mV, sign='above', # this can occur when extraction interval indexes beyond the signal. # Workaround: delete spikes shorter than the maximum length with if len(np.shape(waveforms)) == 1: - max_len = (np.array([len(x) for x in waveforms])).max() + max_len = max(len(waveform) for waveform in waveforms) to_delete = np.array([idx for idx, x in enumerate(waveforms) if len(x) < max_len]) waveforms = np.delete(waveforms, to_delete, axis=0) - waveforms = np.array(waveforms) warnings.warn("Waveforms " + ("{:d}, " * len(to_delete)).format(*to_delete) + "exceeded signal and had to be deleted. " + @@ -333,46 +344,720 @@ def peak_detection(signal, threshold=0.0 * pq.mV, sign='above', return result_st -def _homogeneous_process(interval_generator, mean_rate, t_start, t_stop, - as_array): +class AbstractPointProcess: """ - Returns a spike train whose spikes are a realization of a random process - generated by the function `interval_generator` with the given rate, - starting at time `t_start` and stopping `time t_stop`. + Abstract point process to subclass from. + + Parameters + ---------- + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + """ + def __init__( + self, + t_stop: pq.Quantity = 1.*pq.s, + t_start: pq.Quantity = 0.*pq.s + ): + if not (isinstance(t_start, pq.Quantity) and + isinstance(t_stop, pq.Quantity)): + raise ValueError("t_start and t_stop must be of type pq.Quantity") + if t_stop <= t_start: + raise ValueError('t_start must be smaller than t_stop.') + + self.units = t_stop.units + self._t_stop = t_stop.item() + self._t_start = t_start.rescale(self.units).item() + + @property + def t_start(self): + """ + t_start quantity; there are no spike times below this value. + """ + return self._t_start * self.units + + @property + def t_stop(self): + """ + t_stop quantity; there are no spike times above this value. + """ + return self._t_stop * self.units + + def _generate_spiketrain_as_array(self) -> np.ndarray: + raise NotImplementedError + + def generate_spiketrain( + self, as_array: bool = False + ) -> Union[neo.SpikeTrain, np.ndarray]: + """ + Generates a single spike train. + + Parameters + ---------- + as_array : bool, optional + If True, a NumPy array of sorted spikes is returned, + rather than a `neo.SpikeTrain` object. + Default: False + + Returns + ------- + spiketrain : neo.SpikeTrain or np.ndarray + The generated spike train in the specified format. + """ + spikes = self._generate_spiketrain_as_array() + if as_array: + return spikes + # else: + return neo.SpikeTrain( + spikes, + t_start=self.t_start, t_stop=self.t_stop, units=self.units) + + def generate_n_spiketrains( + self, + n_spiketrains: int, + as_array: bool = False + ) -> Union[List[neo.SpikeTrain], List[np.ndarray]]: + """ + Generates a list of spike trains. + + Parameters + ---------- + n_spiketrains : int + The number of spike trains to generate. + as_array : bool, optional + If True, a NumPy array of sorted spikes is returned, + rather than a `neo.SpikeTrain` object. + Default: False + + Returns + ------- + list_of_spiketrain : list of neo.SpikeTrain or list of np.ndarray + A list generated spike trains in the specified format. + """ + return [self.generate_spiketrain(as_array=as_array) + for _ in range(n_spiketrains)] + + +class RenewalProcess(AbstractPointProcess): + """ + Abstract renewal process to subclass from. + + Parameters + ---------- + rate : pq.Quantity + The constant firing rate. + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + equilibrium : bool, optional + Generate an equilibrium or an ordinary renewal process. + Default: True """ - t_start = t_start.rescale(t_stop.units) - n_spikes_expected = int(np.ceil( - ((t_stop - t_start) * mean_rate).simplified)) - if n_spikes_expected < 0: - raise ValueError("Expected no. of spikes: {n_spikes} < 0. The firing " - "rate ({rate}) cannot be negative and t_stop " - "({t_stop}) must be greater than t_start " - "({t_start})".format(n_spikes=n_spikes_expected, - rate=mean_rate, - t_stop=t_stop, t_start=t_start)) - spikes = [] - if n_spikes_expected > 0: + isi_generator: stats.rv_continuous + + def __init__( + self, + rate: pq.Quantity, + t_start: pq.Quantity = 0.*pq.s, + t_stop: pq.Quantity = 1.*pq.s, + equilibrium: bool = True + ): + super().__init__(t_start=t_start, t_stop=t_stop) + if not isinstance(rate, pq.Quantity): + raise ValueError("rate must be of type pq.Quantity") + self.rate = rate.rescale(1./self.units).item() + + self.equilibrium = equilibrium + + self.n_expected_spikes = int(np.ceil( + ((self._t_stop - self._t_start) * self.rate))) + + if self.n_expected_spikes < 0: + raise ValueError( + f"Expected no. of spikes: {self.n_expected_spikes} < 0. " + f"The firing rate ({self.rate/self.units}) " + f"cannot be negative.") + + def _cdf_first_spike_equilibrium(self, time): + """ + Integral over the p.d.f. of the first spike which is: + p(t) = rate * survival-function(t) * Heaviside(t). + See Bouss (2020). + + The parameter time is a magnitude of a time value given in seconds. + """ + return self.rate * integrate.quad(self.isi_generator.sf, 0., time)[0] + + def _get_first_spike_equilibrium(self): + """ + Return a numerically drawn sample of the p.d.f of the first spike. + + By solving: + x = integral(c.d.f(t) from 0 to t), + where x is drawn from a uniform distribution. + """ + random_uniform = np.random.random() + equation_solver = root_scalar + + def function_to_solve(time): + """ + # integral(c.d.f(t) from 0 to t) - random-number-x) + """ + return self._cdf_first_spike_equilibrium(time) - random_uniform + + def derivative_of_function_to_solve(time): + """ + derivative of the c.d.f, which is rate times + the survival function + """ + return self.rate * self.isi_generator.sf(time) + + # Initial guess is solution for Poisson process + initial_guess = -np.log(1.-random_uniform)/self.rate + duration = self._t_stop-self._t_start + limits_for_first_spike = (0., duration) + + # test if solution for first spike is inside the boundaries. If not + # return t_stop of the spike train. + if self._cdf_first_spike_equilibrium(duration) <= random_uniform: + return self._t_stop + + non_shifted_position_of_first_spike = equation_solver( + function_to_solve, + x0=initial_guess, + bracket=limits_for_first_spike, + fprime=derivative_of_function_to_solve + ).root + + return non_shifted_position_of_first_spike + self._t_start + + def _generate_spiketrain_as_array(self) -> np.ndarray: + if self.n_expected_spikes == 0: + return np.array([]) + + if self.equilibrium: # equilibrium renewal process + # First spike of equilibrium renewal process drawn according to + # Bouss (2020), Master's Thesis + first_spike = self._get_first_spike_equilibrium() + else: # ordinary renewal process + first_spike = self.isi_generator.rvs() + self._t_start + + spikes = np.array([first_spike]) + # 3 STDs corresponds to 99.7% - n_spikes_expected = int(np.ceil( - n_spikes_expected + 3 * np.sqrt(n_spikes_expected))) - t_last = t_start.simplified.magnitude - while True: - isi = interval_generator(size=n_spikes_expected) - spikes = np.r_[spikes, t_last + np.cumsum(isi)] - # Check if not whole time range is covered. - index_last_spike = spikes.searchsorted(t_stop.simplified.magnitude) - if index_last_spike < len(spikes): - spikes = spikes[:index_last_spike] - spikes = (spikes / mean_rate.units).rescale(t_stop.units) - break - t_last = spikes[-1] - if as_array: - spikes = spikes.magnitude - else: - spikes = neo.SpikeTrain(spikes, t_start=t_start, t_stop=t_stop, - units=t_stop.units) + n_spikes_three_stds = int(np.ceil( + self.n_expected_spikes + 3 * np.sqrt(self.n_expected_spikes))) + + # Continue until whole time range is covered + while spikes[-1] < self._t_stop: + isi = self.isi_generator.rvs(size=n_spikes_three_stds) + + t_last_spike = spikes[-1] + spikes = np.r_[spikes, t_last_spike + np.cumsum(isi)] + + index_last_spike = spikes.searchsorted(self._t_stop) + spikes = spikes[:index_last_spike] + + return spikes + + @property + def expected_cv(self): + """ + The expected coefficient of variation given the ISI distribution. + """ + return self.isi_generator.std()/self.isi_generator.mean() + + +class StationaryPoissonProcess(RenewalProcess): + """ + Generates spike trains whose spikes are realizations of a stationary + Poisson process with the given rate, starting at time `t_start` and + stopping at time `t_stop`. Optionally, a absolute refractory period / + dead time can be specified. + + Parameters + ---------- + rate : pq.Quantity + The constant firing rate. + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + refractory_period : pq.Quantity, optional + The time period after one spike in which no other spike is emitted. + This can be called an absolute refractory period or a dead time as + used in :cite:`generation-Deger12_443`. + Default : None + equilibrium : bool, optional + Generate an equilibrium or an ordinary renewal process. + Default: True + + Raises + ------ + ValueError + If one of `rate`, `t_start` and `t_stop` is not of type `pq.Quantity`. + + If `refractory_period` is not of type `pq.Quantity` nor None. + + If the period between two successive spikes (`1 / rate`) is smaller + or equal than the `refractory_period`. + + Examples + -------- + >>> import quantities as pq + >>> spiketrain = StationaryPoissonProcess(rate=50.*pq.Hz, t_start=0*pq.ms, + ... t_stop=1000*pq.ms).generate_spiketrain() + >>> spiketrain_array = StationaryPoissonProcess( + ... rate=20*pq.Hz, t_start=5000*pq.ms, t_stop=10000*pq.ms + ... ).generate_spiketrain(as_array=True) + >>> spiketrain = StationaryPoissonProcess( + ... rate=50*pq.Hz, + ... t_start=0*pq.ms, t_stop=1000*pq.ms, + ... refractory_period = 3*pq.ms).generate_spiketrain() + """ + def __init__( + self, + rate: pq.Quantity, + t_stop: pq.Quantity = 1.*pq.s, + t_start: pq.Quantity = 0.*pq.s, + refractory_period: Optional[pq.Quantity] = None, + equilibrium: bool = True + ): + super().__init__( + rate=rate, t_start=t_start, t_stop=t_stop, equilibrium=equilibrium) + + if refractory_period is not None: + if not isinstance(refractory_period, pq.Quantity): + raise ValueError( + "refractory_period must be of type pq.Quantity") + self.refractory_period = refractory_period.rescale( + self.units).item() + + if self.rate * self.refractory_period >= 1.: + raise ValueError( + "Period between two successive spikes must be larger " + "than the refractory period. Decrease either the " + "firing rate or the refractory period.") + else: + self.refractory_period = refractory_period + + if self.n_expected_spikes > 0 and refractory_period is None: + self.isi_generator = stats.expon(scale=1./self.rate) + + elif self.n_expected_spikes > 0 and refractory_period is not None: + self.effective_rate = self.rate / \ + (1. - self.rate * self.refractory_period) + self.isi_generator = stats.expon( + scale=1. / self.effective_rate, loc=self.refractory_period) + + def _get_first_spike_equilibrium(self): + if self.refractory_period is None: + return self.isi_generator.rvs() + self._t_start + + # the case with dead time + random_uniform = np.random.random() + if random_uniform <= self.rate * self.refractory_period: + return random_uniform / self.rate + self._t_start + # random_uniform > self.rate * self.refractory_period + return (np.log(1. - self.rate * self.refractory_period) + - np.log(1. - random_uniform) + ) / self.effective_rate + self.refractory_period + + @property + def expected_cv(self): + """ + The expected coefficient of variation given the ISI distribution. + """ + if self.refractory_period is None: + return 1. + + # the case with dead time + return 1. - self.rate * self.refractory_period + + +class StationaryGammaProcess(RenewalProcess): + """ + Generates spike trains whose spikes are realizations of a stationary + Gamma process with the given rate and `shape_factor` + starting at time `t_start` and stopping at time `t_stop`. + + Parameters + ---------- + rate : pq.Quantity + The constant firing rate. + shape_factor : float + The shape parameter of the gamma distribution. + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + equilibrium : bool, optional + Generate an equilibrium or an ordinary renewal process. + Default: True + + Raises + ------ + ValueError + If one of `rate`, `t_start` and `t_stop` is not of type `pq.Quantity`. + + Examples + -------- + >>> import quantities as pq + >>> spiketrain = StationaryGammaProcess( + ... rate=50*pq.Hz, shape_factor=2.0, t_start=0*pq.ms, + ... t_stop=1000*pq.ms).generate_spiketrain() + >>> spiketrain_array = StationaryGammaProcess( + ... rate=20*pq.Hz, shape_factor=5.0, t_start=5000*pq.ms, + ... t_stop=10000*pq.ms).generate_spiketrain(as_array=True) + """ + def __init__( + self, + rate: pq.Quantity, + shape_factor: float, + t_start: pq.Quantity = 0.*pq.s, + t_stop: pq.Quantity = 1.*pq.s, + equilibrium: bool = True + ): + super().__init__( + rate=rate, t_start=t_start, t_stop=t_stop, equilibrium=equilibrium) + if self.n_expected_spikes > 0: + self.shape_factor = shape_factor + self.isi_generator = stats.gamma( + a=shape_factor, scale=1./(shape_factor * self.rate)) + + def _cdf_first_spike_equilibrium(self, time): + """ + The parameter time is a magnitude of a time value given in seconds. + """ + if time < 0.: + return 0. + return self.rate * time * \ + gammaincc(self.shape_factor, + self.shape_factor*self.rate*time)\ + + gammainc(self.shape_factor+1., + self.shape_factor*self.rate*time) + + @property + def expected_cv(self): + """ + The expected coefficient of variation given the ISI distribution. + """ + return 1./np.sqrt(self.shape_factor) + + +class StationaryLogNormalProcess(RenewalProcess): + """ + Generates spike trains whose spikes are realizations of a stationary + LogNormal process with the given rate and `sigma` + starting at time `t_start` and stopping at time `t_stop`. + + Parameters + ---------- + rate : pq.Quantity + The constant firing rate. + sigma : float + The sigma/ s parameter of the Log-Normal distribution. + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + equilibrium : bool, optional + Generate an equilibrium or an ordinary renewal process. + Default: True + + Raises + ------ + ValueError + If one of `rate`, `t_start` and `t_stop` is not of type `pq.Quantity`. + + Examples + -------- + >>> import quantities as pq + >>> spiketrain = StationaryLogNormalProcess( + ... rate=50*pq.Hz, sigma=2.0, t_start=0*pq.ms, + ... t_stop=1000*pq.ms).generate_spiketrain() + >>> spiketrain_array = StationaryLogNormalProcess( + ... rate=20*pq.Hz, sigma=5.0, t_start=5000*pq.ms, + ... t_stop=10000*pq.ms).generate_spiketrain(as_array=True) + """ + def __init__( + self, + rate: pq.Quantity, + sigma: float, + t_start: pq.Quantity = 0.*pq.s, + t_stop: pq.Quantity = 1.*pq.s, + equilibrium: bool = True + ): + super().__init__( + rate=rate, t_start=t_start, t_stop=t_stop, equilibrium=equilibrium) + self.sigma = sigma + if self.n_expected_spikes > 0: + self.isi_generator = stats.lognorm( + s=self.sigma, scale=np.exp(self.mu)) + + @property + def mu(self): + """ + The parameter mu of the log-normal distribution. + """ + return -np.log(self.rate) - self.sigma**2/2 + + @property + def expected_cv(self): + """ + The expected coefficient of variation given the ISI distribution. + """ + return np.sqrt(np.exp(self.sigma**2) - 1) + + +class StationaryInverseGaussianProcess(RenewalProcess): + """ + Generates spike trains whose spikes are realizations of a stationary + Gamma process with the given rate and `cv` + starting at time `t_start` and stopping at time `t_stop`. + + Raises + ------ + ValueError + If one of `rate`, `t_start` and `t_stop` is not of type `pq.Quantity`. + + Parameters + ---------- + rate : pq.Quantity + The constant firing rate. + cv : float + The expected coefficient of variation. + t_start : pq.Quantity, optional + The start of the spike train. + Default: 0.*pq.s + t_stop : pq.Quantity, optional + The end of the spike train. + Default: 1.*pq.s + equilibrium : bool, optional + Generate an equilibrium or an ordinary renewal process. + Default: True + + Examples + -------- + >>> import quantities as pq + >>> spiketrain = StationaryInverseGaussianProcess( + ... rate=50*pq.Hz, cv=2.0, t_start=0*pq.ms, + ... t_stop=1000*pq.ms).generate_spiketrain() + >>> spiketrain_array = StationaryInverseGaussianProcess( + ... rate=20*pq.Hz, cv=5.0, t_start=5000*pq.ms, + ... t_stop=10000*pq.ms).generate_spiketrain(as_array=True) + """ + def __init__( + self, + rate: pq.Quantity, + cv: float, + t_start: pq.Quantity = 0.*pq.s, + t_stop: pq.Quantity = 1.*pq.s, + equilibrium: bool = True + ): + super().__init__( + rate=rate, t_start=t_start, t_stop=t_stop, equilibrium=equilibrium) + self._cv = cv + if self.n_expected_spikes > 0: + self.isi_generator = stats.invgauss( + mu=cv**2, scale=1./(self.rate*cv**2)) + + @property + def expected_cv(self): + """ + The expected coefficient of variation given the ISI distribution. + """ + return self._cv + + +class RateModulatedProcess(AbstractPointProcess): + """ + Abstract rate-modulated process to subclass from. + + Parameters + ---------- + rate_signal : neo.AnalogSignal + A `neo.AnalogSignal` representing the rate profile evolving over + time. Its values have all to be `>=0`. The generated spike trains + will have `t_start = rate.t_start` and `t_stop = rate.t_stop` + + Raises + ------ + ValueError + If `rate_signal` is not a neo AnalogSignal + If `rate_signal` contains a negative value. + If `rate_signal` is empty. + """ + process_operational_time: RenewalProcess + + def __init__(self, rate_signal: neo.AnalogSignal): + + if not isinstance(rate_signal, neo.AnalogSignal): + raise ValueError( + f'rate_signal should be of type neo.AnalogSignal.' + f' Currently it is of type: {type(rate_signal)}') + if len(rate_signal) == 0: + raise ValueError('rate_signal can not be empty.') + if any(rate_signal < 0): + raise ValueError( + 'All elements of rate_signal should be positive.') + + super().__init__( + t_start=rate_signal.t_start, t_stop=rate_signal.t_stop) + + self.rate_signal = rate_signal + + self.mean_rate = np.mean(rate_signal.rescale(1./self.units).magnitude) + + if self.mean_rate == 0.: + # if the firing rate is zero, the init functions stops here, since + # the other parameters are then not needed. + return None + + self.sampling_period = \ + self.rate_signal.sampling_period.rescale(self.units).magnitude + # Operational time corresponds to the integral of the firing rate + # over time, here normalized by the average firing rate + operational_time = np.cumsum( + rate_signal.rescale(1./self.units).magnitude) + operational_time *= (self.sampling_period / self.mean_rate) + operational_time = np.hstack((0., operational_time)) + self.operational_time = operational_time + self._t_start + + # The time points at which the firing rates are given + self.real_time = np.hstack( + (rate_signal.times.rescale(self.units).magnitude, + self._t_stop)) + + def _generate_spiketrain_as_array(self) -> np.ndarray: + spiketrain_operational_time = \ + self.process_operational_time._generate_spiketrain_as_array() + if len(spiketrain_operational_time) == 0: + return spiketrain_operational_time + # indices where between which points in operational time the spikes lie + indices = np.searchsorted(self.operational_time, + spiketrain_operational_time) + + # In real time the spikes are first aligned + # to the left border of the bin. + # Note that indices are greater than 0 because 'operational_time' was + # padded with zeros. + spiketrain = self.real_time[indices - 1] + # the relative position of the spikes in the operational time bins + positions_in_bins = \ + (spiketrain_operational_time + - self.operational_time[indices - 1]) / \ + (self.operational_time[indices] + - self.operational_time[indices - 1]) + + # add the positions in the bin times the sampling period in real time + spiketrain += self.sampling_period * positions_in_bins + return spiketrain + + +class NonStationaryPoissonProcess(RateModulatedProcess): + """ + Generates spike trains whose spikes are realizations of a non-stationary + Poisson process with the given `rate-signal`. Optionally, you can specify a + dead time. + + Parameters + ---------- + rate_signal : neo.AnalogSignal + A `neo.AnalogSignal` representing the rate profile evolving over + time.Its values have all to be `>=0`. The generated spike trains + will have `t_start = rate.t_start` and `t_stop = rate.t_stop` + refractory_period : pq.Quantity, optional + The time period after one spike in which no other spike is emitted. + This can be called an absolute refractory period or a dead time. + Default : None + + Raises + ------ + ValueError + If `rate_signal` is not a neo AnalogSignal + If `rate_signal` contains a negative value. + If `rate_signal` is empty. + If `refractory_period` is not of type `pq.Quantity` nor None. + """ + def __init__(self, rate_signal: neo.AnalogSignal, + refractory_period: Optional[pq.Quantity] = None): + + if refractory_period is not None: + if not isinstance(refractory_period, pq.Quantity): + raise ValueError( + "refractory_period must be of type pq.Quantity") + rate_signal = \ + rate_signal / (1. - rate_signal.simplified.magnitude + * refractory_period.simplified.item()) - return spikes + super().__init__(rate_signal=rate_signal) + self.process_operational_time = StationaryPoissonProcess( + rate=self.mean_rate * 1./self.units, + t_start=self.t_start, + t_stop=self.t_stop) + + self.refractory_period = refractory_period + if self.refractory_period is not None: + self.refractory_period = self.refractory_period.rescale( + self.units).item() + + def _generate_spiketrain_as_array(self) -> np.ndarray: + if self.refractory_period is None: + return super()._generate_spiketrain_as_array() + + spiketrain = super()._generate_spiketrain_as_array() + thinned_spiketrain = [] + + previous_spike = self._t_start - self.refractory_period + + for spike in spiketrain: + if spike > previous_spike + self.refractory_period: + thinned_spiketrain.append(spike) + previous_spike = spike + return np.array(thinned_spiketrain) + + +class NonStationaryGammaProcess(RateModulatedProcess): + """ + Generates spike trains whose spikes are realizations of a non-stationary + Gamma process with the given `rate-signal`. + + Parameters + ---------- + rate_signal : neo.AnalogSignal + A `neo.AnalogSignal` representing the rate profile evolving over + time.Its values have all to be `>=0`. The generated spike trains + will have `t_start = rate.t_start` and `t_stop = rate.t_stop` + shape_factor : float + The shape parameter of the gamma distribution. + + Raises + ------ + ValueError + If `rate_signal` is not a neo AnalogSignal + If `rate_signal` contains a negative value. + If `rate_signal` is empty. + """ + def __init__(self, rate_signal: neo.AnalogSignal, shape_factor: float): + super().__init__(rate_signal=rate_signal) + self.process_operational_time = StationaryGammaProcess( + rate=self.mean_rate * 1./self.units, + shape_factor=shape_factor, + t_start=self.t_start, + t_stop=self.t_stop) def homogeneous_poisson_process(rate, t_start=0.0 * pq.ms, @@ -430,48 +1115,13 @@ def homogeneous_poisson_process(rate, t_start=0.0 * pq.ms, ... t_stop=1000*pq.ms, refractory_period = 3*pq.ms) """ - if not (isinstance(t_start, pq.Quantity) and - isinstance(t_stop, pq.Quantity)): - raise ValueError("t_start and t_stop must be of type pq.Quantity") - if not isinstance(rate, pq.Quantity): - raise ValueError("rate must be of type pq.Quantity") - if not isinstance(refractory_period, pq.Quantity) and \ - refractory_period is not None: - raise ValueError("refractory_period must be of type pq.Quantity or" - "None") - - rate = rate.simplified - - # Case without a refractory period - if refractory_period is None: - interval_generator = partial(np.random.exponential, - scale=1. / rate.magnitude) - return _homogeneous_process( - interval_generator, rate, t_start, t_stop, - as_array) - - # Case with a refractory period - refractory_period = refractory_period.simplified - - if rate * refractory_period >= 1.: - raise ValueError("Period between two successive spikes must be larger " - "than the refractory period. Decrease either the " - "firing rate or the refractory period.") - - effective_rate = rate / (1. - rate * refractory_period) - - def interval_generator_refractory(size): - return refractory_period.magnitude + \ - np.random.exponential(1. / effective_rate.magnitude, size) - - # we subtract refractory_period from t_start to be added later on - # in interval_generator_refractory() - spiketrain = _homogeneous_process(interval_generator_refractory, rate, - t_start - refractory_period, t_stop, - as_array) - if not as_array: - spiketrain.t_start = t_start - return spiketrain + warnings.warn( + "'homogeneous_poisson_process' is deprecated;" + " use 'StationaryPoissonProcess'.", DeprecationWarning) + process = StationaryPoissonProcess( + rate=rate, t_start=t_start, t_stop=t_stop, + refractory_period=refractory_period, equilibrium=False) + return process.generate_spiketrain(as_array=as_array) def inhomogeneous_poisson_process(rate, as_array=False, @@ -512,135 +1162,15 @@ def inhomogeneous_poisson_process(rate, as_array=False, successive spikes (`1 / rate`) is smaller than the `refractory_period`. """ - # Check rate contains only positive values - if np.any(rate < 0) or rate.size == 0: - raise ValueError( - 'rate must be a positive non empty signal, representing the' - 'rate at time t') - if not isinstance(refractory_period, pq.Quantity) and \ - refractory_period is not None: - raise ValueError("refractory_period must be of type pq.Quantity or" - "None") - - rate_max = np.max(rate) - if refractory_period is not None: - if (rate_max * refractory_period).simplified >= 1.: - raise ValueError( - "Period between two successive spikes must be larger " - "than the refractory period. Decrease either the " - "firing rate or the refractory period.") - # effective rate parameter for the refractory period case - rate = rate / (1. - (rate * refractory_period).simplified) - rate_max = np.max(rate) - - # Generate n hidden Poisson SpikeTrains with rate equal - # to the peak rate - homogeneous_poiss = homogeneous_poisson_process( - rate=rate_max, t_stop=rate.t_stop, t_start=rate.t_start) - # Compute the rate profile at each spike time by interpolation - rate_interpolated = _analog_signal_linear_interp( - signal=rate, times=homogeneous_poiss.times) - # Accept each spike at time t with probability rate(t)/max_rate - random_uniforms = np.random.uniform(size=len(homogeneous_poiss)) * rate_max - spikes = homogeneous_poiss[random_uniforms < rate_interpolated.flatten()] - - if refractory_period is not None: - refractory_period = refractory_period.rescale( - rate.t_stop.units).magnitude - # thinning in average cancels the effect of the effective firing rate - spikes = _thinning_for_refractory_period(spikes.magnitude, - refractory_period) - if not as_array: - spikes = neo.SpikeTrain(spikes * rate.t_stop.units, - t_start=rate.t_start, - t_stop=rate.t_stop) - else: - if as_array: - spikes = spikes.magnitude - return spikes - - -def _thinning_for_refractory_period(spiketrain, refractory_period): - """ - Function to thin out a spiketrain, that every ISI is greater than the - refractory period. - - Parameters - ---------- - spiketrain : np.ndarray - Magnitude of a spiketrain. - refractory_period : float - Magnitude of a refractory period. - - Returns - ------- - thinned_spiketrain : np.ndarray - thinned out spiketrain - """ - thinned_spiketrain = [] - previous_spike = -refractory_period - for spike in spiketrain: - if spike > previous_spike + refractory_period: - thinned_spiketrain.append(spike) - previous_spike = spike - return np.array(thinned_spiketrain) - - -def _analog_signal_linear_interp(signal, times): - """ - Compute the linear interpolation of a signal at desired times. - - Given the `signal` (neo.AnalogSignal) taking value `s0` and `s1` at two - consecutive time points `t0` and `t1` `(t0 < t1)`, for every time `t` in - `times`, such that `t0 0): raise ValueError( - 'n (={}) must be a positive integer'.format(str(n_spiketrains))) - rate_dl = rate.simplified.magnitude.flatten() - - # Check rate input parameter - if len(rate_dl) == 1: - if rate_dl < 0: - raise ValueError('rate (={}) must be non-negative.'.format(rate)) - rates = np.array([rate_dl] * n_spiketrains) - else: - rates = rate_dl.flatten() - if any(rates < 0): - raise ValueError('rate must have non-negative elements.') + f'n_spiketrains (={n_spiketrains}) must be a positive integer') - return [homogeneous_poisson_process(rate * pq.Hz, t_start, t_stop) - for rate in rates] + # one rate for all spike trains + if rate.ndim == 0: + return StationaryPoissonProcess( + rate=rate, t_start=t_start, t_stop=t_stop + ).generate_n_spiketrains(n_spiketrains) + + # different rate for each spike train + return [StationaryPoissonProcess( + rate=single_rate, t_start=t_start, t_stop=t_stop).generate_spiketrain() + for single_rate in rate] @deprecated_alias(rate_c='coincidence_rate', n='n_spiketrains', @@ -921,17 +1401,15 @@ def single_interaction_process( -------- >>> import quantities as pq >>> import elephant.spike_train_generation as stg - # TODO: check if rate_coincidence=4 is correct. >>> sip, coinc = stg.single_interaction_process( - ... rate=20*pq.Hz, coincidence_rate=4, + ... rate=20*pq.Hz, coincidence_rate=4.*pq.Hz, ... t_stop=1*pq.s, n_spiketrains=10, return_coincidences = True) - """ # Check if n is a positive integer if not (isinstance(n_spiketrains, int) and n_spiketrains > 0): raise ValueError( - 'n (={}) must be a positive integer'.format(n_spiketrains)) + f'n_spiketrains (={n_spiketrains}) must be a positive integer') if coincidences not in ('deterministic', 'stochastic'): raise ValueError( "coincidences must be 'deterministic' or 'stochastic'") @@ -945,11 +1423,11 @@ def single_interaction_process( if rate.ndim == 0: if rate < 0 * pq.Hz: raise ValueError( - 'rate (={}) must be non-negative.'.format(rate)) + f'rate (={rate}) must be non-negative.') rates_b = np.repeat(rate, n_spiketrains) else: rates_b = rate.flatten() - if not all(rates_b >= 0. * pq.Hz): + if not all(rates_b >= 0.*pq.Hz): raise ValueError('*rate* must have non-negative elements') # Check: rate>=rate_coincidence @@ -989,9 +1467,10 @@ def single_interaction_process( if len(coinc_times) < 2 or min(np.diff(coinc_times)) >= min_delay: break else: # coincidences == 'stochastic' + poisson_process = StationaryPoissonProcess( + rate=coincidence_rate, t_stop=t_stop, t_start=t_start) while True: - coinc_times = homogeneous_poisson_process( - rate=coincidence_rate, t_stop=t_stop, t_start=t_start) + coinc_times = poisson_process.generate_spiketrain() if len(coinc_times) < 2 or min(np.diff(coinc_times)) >= min_delay: break coinc_times = coinc_times.simplified @@ -1083,41 +1562,6 @@ def _pool_two_spiketrains(spiketrain_1, spiketrain_2, extremes='inner'): t_stop=t_stop) -def _pool_spiketrains(spiketrains, extremes='inner'): - """ - Pool spikes from any number of spike trains into a unique spike train. - - Parameters - ---------- - spiketrains : list of neo.SpikeTrain - A list of spiketrains to merge. - extremes : str, optional - Only spikes of a and b in the specified extremes are considered. - * 'inner': pool all spikes from min(a.t_start b.t_start) to - max(a.t_stop, b.t_stop) - * 'outer': pool all spikes from max(a.tstart_ b.t_start) to - min(a.t_stop, b.t_stop) - Default: 'inner' - - Returns - ------- - neo.SpikeTrain - containing all spikes in trains falling in the specified extremes - """ - - merge_trains = spiketrains[0] - for spiketrain in spiketrains[1:]: - merge_trains = _pool_two_spiketrains( - merge_trains, spiketrain, extremes=extremes) - t_start, t_stop = merge_trains.t_start, merge_trains.t_stop - merge_trains = sorted(merge_trains) - merge_trains = np.squeeze(merge_trains) - merge_trains = neo.SpikeTrain( - merge_trains, t_stop=t_stop, t_start=t_start, - units=spiketrains[0].units) - return merge_trains - - def _sample_int_from_pdf(probability_density, n_samples): """ Draw n independent samples from the set {0,1,...,L}, where L=len(a)-1, @@ -1147,7 +1591,8 @@ def _sample_int_from_pdf(probability_density, n_samples): return (cumulative_distribution < random_uniforms).sum(axis=1) -def _mother_proc_cpp_stat(A, t_stop, rate, t_start=0 * pq.ms): +def _mother_proc_cpp_stat( + amplitude_distribution, t_stop, rate, t_start=0 * pq.ms): """ Generate the hidden ("mother") Poisson process for a Compound Poisson Process (CPP). @@ -1155,10 +1600,11 @@ def _mother_proc_cpp_stat(A, t_stop, rate, t_start=0 * pq.ms): Parameters ---------- - A : np.ndarray - Amplitude distribution. A[j] represents the probability of a - synchronous event of size j. - The sum over all entries of a must be equal to one. + amplitude_distribution : np.ndarray + CPP's amplitude distribution :math:`A`. `A[j]` represents the + probability of a synchronous event of size `j` among the generated + spike trains. The sum over all entries of :math:`A` must be equal to + one. t_stop : pq.Quantity The stopping time of the mother process rate : pq.Quantity @@ -1172,26 +1618,29 @@ def _mother_proc_cpp_stat(A, t_stop, rate, t_start=0 * pq.ms): ------- Poisson spike train representing the mother process generating the CPP """ - n_spiketrains = len(A) - 1 + n_spiketrains = len(amplitude_distribution) - 1 # expected amplitude - exp_amplitude = np.dot(A, np.arange(n_spiketrains + 1)) + exp_amplitude = np.dot( + amplitude_distribution, np.arange(n_spiketrains + 1)) # expected rate of the mother process exp_mother_rate = (n_spiketrains * rate) / exp_amplitude - return homogeneous_poisson_process( - rate=exp_mother_rate, t_stop=t_stop, t_start=t_start) + return StationaryPoissonProcess( + rate=exp_mother_rate, t_stop=t_stop, t_start=t_start + ).generate_spiketrain() -def _cpp_hom_stat(A, t_stop, rate, t_start=0 * pq.ms): +def _cpp_hom_stat(amplitude_distribution, t_stop, rate, t_start=0 * pq.ms): """ Generate a Compound Poisson Process (CPP) with amplitude distribution A and heterogeneous firing rates r=r[0], r[1], ..., r[-1]. Parameters ---------- - A : np.ndarray - Amplitude distribution. A[j] represents the probability of a - synchronous event of size j. - The sum over all entries of A must be equal to one. + amplitude_distribution : np.ndarray + CPP's amplitude distribution :math:`A`. `A[j]` represents the + probability of a synchronous event of size `j` among the generated + spike trains. The sum over all entries of :math:`A` must be equal to + one. t_stop : pq.Quantity The end time of the output spike trains rate : pq.Quantity @@ -1209,9 +1658,11 @@ def _cpp_hom_stat(A, t_stop, rate, t_start=0 * pq.ms): # Generate mother process and associated spike labels mother = _mother_proc_cpp_stat( - A=A, t_stop=t_stop, rate=rate, t_start=t_start) - labels = _sample_int_from_pdf(A, len(mother)) - n_spiketrains = len(A) - 1 # Number of trains in output + amplitude_distribution=amplitude_distribution, + t_stop=t_stop, rate=rate, t_start=t_start) + labels = _sample_int_from_pdf(amplitude_distribution, len(mother)) + n_spiketrains = len(amplitude_distribution) - 1 + # Number of trains in output spiketrains = [[]] * n_spiketrains try: # Faster but more memory-consuming approach @@ -1239,17 +1690,18 @@ def _cpp_hom_stat(A, t_stop, rate, t_start=0 * pq.ms): for spiketrain in spiketrains] -def _cpp_het_stat(A, t_stop, rates, t_start=0. * pq.ms): +def _cpp_het_stat(amplitude_distribution, t_stop, rates, t_start=0.*pq.ms): """ Generate a Compound Poisson Process (CPP) with amplitude distribution A and heterogeneous firing rates r=r[0], r[1], ..., r[-1]. Parameters ---------- - A : np.ndarray - CPP's amplitude distribution. A[j] represents the probability of - a synchronous event of size j among the generated spike trains. - The sum over all entries of A must be equal to one. + amplitude_distribution : np.ndarray + CPP's amplitude distribution :math:`A`. `A[j]` represents the + probability of a synchronous event of size `j` among the generated + spike trains. The sum over all entries of :math:`A` must be equal to + one. t_stop : pq.Quantity The end time of the output spike trains rates : pq.Quantity @@ -1269,7 +1721,8 @@ def _cpp_het_stat(A, t_stop, rates, t_start=0. * pq.ms): # (uncorrelated with heterog. rates + correlated with homog. rates) n_spiketrains = len(rates) # number of output spike trains # amplitude expectation - expected_amplitude = np.dot(A, np.arange(n_spiketrains + 1)) + expected_amplitude = np.dot( + amplitude_distribution, np.arange(n_spiketrains + 1)) r_sum = np.sum(rates) # sum of all output firing rates r_min = np.min(rates) # minimum of the firing rates @@ -1281,19 +1734,23 @@ def _cpp_het_stat(A, t_stop, rates, t_start=0. * pq.ms): r_mother = r_uncorrelated + r_correlated # Check the analytical constraint for the amplitude distribution - if A[1] < (r_uncorrelated / r_mother).rescale( + if amplitude_distribution[1] < (r_uncorrelated / r_mother).rescale( pq.dimensionless).magnitude: raise ValueError('A[1] too small / A[i], i>1 too high') # Compute the amplitude distribution of the correlated CPP, and generate it - A = A * (r_mother / r_correlated).magnitude - A[1] = A[1] - r_uncorrelated / r_correlated + amplitude_distribution = \ + amplitude_distribution * (r_mother / r_correlated).magnitude + amplitude_distribution[1] = \ + amplitude_distribution[1] - r_uncorrelated / r_correlated compound_poisson_spiketrains = _cpp_hom_stat( - A, t_stop, r_min, t_start) + amplitude_distribution, t_stop, r_min, t_start) # Generate the independent heterogeneous Poisson processes poisson_spiketrains = \ - [homogeneous_poisson_process(rate - r_min, t_start, t_stop) + [StationaryPoissonProcess( + rate=rate - r_min, t_start=t_start, t_stop=t_stop + ).generate_spiketrain() for rate in rates] # Pool the correlated CPP and the corresponding Poisson processes @@ -1359,8 +1816,8 @@ def compound_poisson_process( # Check A is a probability distribution (it sums to 1 and is positive) if abs(sum(amplitude_distribution) - 1) > np.finfo('float').eps: raise ValueError( - "'amplitude_distribution' must be a probability vector: " - "sum(A) = {} != 1".format(sum(amplitude_distribution))) + f"'amplitude_distribution' must be a probability vector: " + f"sum(A) = {sum(amplitude_distribution)} != 1") if np.any(amplitude_distribution < 0): raise ValueError("'amplitude_distribution' must be a probability " "vector with positive entries") @@ -1377,12 +1834,14 @@ def compound_poisson_process( # Homogeneous rates if rate.ndim == 0: compound_poisson_spiketrains = _cpp_hom_stat( - A=amplitude_distribution, t_stop=t_stop, rate=rate, + amplitude_distribution=amplitude_distribution, + t_stop=t_stop, rate=rate, t_start=t_start) # Heterogeneous rates else: compound_poisson_spiketrains = _cpp_het_stat( - A=amplitude_distribution, t_stop=t_stop, rates=rate, + amplitude_distribution=amplitude_distribution, + t_stop=t_stop, rates=rate, t_start=t_start) if shift is not None: diff --git a/elephant/test/test_spike_train_generation.py b/elephant/test/test_spike_train_generation.py index 0a4bb9569..457e376c6 100644 --- a/elephant/test/test_spike_train_generation.py +++ b/elephant/test/test_spike_train_generation.py @@ -16,10 +16,9 @@ import numpy as np from numpy.testing import assert_array_almost_equal, assert_allclose import quantities as pq -from scipy.stats import expon -from scipy.stats import kstest, poisson +from scipy.stats import expon, kstest, poisson, variation -import elephant.spike_train_generation as stgen +import elephant.spike_train_generation as stg from elephant.statistics import isi, instantaneous_rate from elephant import kernels @@ -53,7 +52,7 @@ def test_threshold_detection(self): # Test whether spikes are extracted at the correct times from # an analog signal. - spike_train = stgen.threshold_detection(self.vm) + spike_train = stg.threshold_detection(self.vm) try: len(spike_train) # Handles an error in Neo related to some zero length @@ -78,7 +77,7 @@ def test_threshold_detection(self): def test_peak_detection_threshold(self): # Test for empty SpikeTrain when threshold is too high - result = stgen.threshold_detection(self.vm, threshold=30 * pq.mV) + result = stg.threshold_detection(self.vm, threshold=30 * pq.mV) self.assertEqual(len(result), 0) @@ -99,7 +98,7 @@ def setUp(self): def test_peak_detection_time_stamps(self): # Test with default arguments - result = stgen.peak_detection(self.vm) + result = stg.peak_detection(self.vm) self.assertEqual(len(self.true_time_stamps), len(result)) self.assertIsInstance(result, neo.core.SpikeTrain) @@ -110,7 +109,7 @@ def test_peak_detection_time_stamps(self): def test_peak_detection_threshold(self): # Test for empty SpikeTrain when threshold is too high - result = stgen.peak_detection(self.vm, threshold=30 * pq.mV) + result = stg.peak_detection(self.vm, threshold=30 * pq.mV) self.assertEqual(len(result), 0) @@ -138,20 +137,22 @@ def setUp(self): -0.06715259, -0.06703235, -0.06691635]) def test_spike_extraction_waveform(self): - spike_train = stgen.spike_extraction(self.vm.reshape(-1), - interval=(-1 * pq.ms, 2 * pq.ms)) - try: - assert_array_almost_equal( - spike_train.waveforms[0][0].magnitude.reshape(-1), - self.first_spike) - except AttributeError: - self.assertTrue( - np.array_equal(spike_train.waveforms[0][0].magnitude, - self.first_spike)) + spike_train = stg.spike_extraction(self.vm.reshape(-1), + interval=(-1 * pq.ms, 2 * pq.ms)) + assert_array_almost_equal( + spike_train.waveforms[0][0].magnitude.reshape(-1), + self.first_spike) -class HomogeneousPoissonProcessTestCase(unittest.TestCase): +class AbstractPointProcessTestCase(unittest.TestCase): + def test_not_implemented_error(self): + process = stg.AbstractPointProcess() + self.assertRaises( + NotImplementedError, process._generate_spiketrain_as_array) + + +class StationaryPoissonProcessTestCase(unittest.TestCase): def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that @@ -159,12 +160,21 @@ def test_statistics(self): for rate in [123.0 * pq.Hz, 0.123 * pq.kHz]: for t_stop in [2345 * pq.ms, 2.345 * pq.s]: - # zero refractory period should act as no refractory period - for refractory_period in (None, 0 * pq.ms): - np.random.seed(seed=12345) - spiketrain = stgen.homogeneous_poisson_process( + for refractory_period in (None, 3.*pq.ms): + np.random.seed(seed=123456) + spiketrain_old = stg.homogeneous_poisson_process( rate, t_stop=t_stop, refractory_period=refractory_period) + np.random.seed(seed=123456) + + spiketrain = stg.StationaryPoissonProcess( + rate, t_stop=t_stop, + refractory_period=refractory_period, + equilibrium=False + ).generate_spiketrain() + assert_array_almost_equal( + spiketrain_old.magnitude, + spiketrain.magnitude) intervals = isi(spiketrain) expected_mean_isi = 1. / rate.simplified @@ -182,37 +192,62 @@ def test_statistics(self): self.assertLess(expected_last_spike - spiketrain[-1], 7 * expected_mean_isi) - # Kolmogorov-Smirnov test - D, p = kstest( - intervals.rescale(t_stop.units), - "expon", - # args are (loc, scale) - args=(0, - expected_mean_isi.rescale(t_stop.units)), - alternative='two-sided') + if refractory_period is None: + # Kolmogorov-Smirnov test + D, p = kstest( + intervals.rescale(t_stop.units).magnitude, + "expon", + # args are (loc, scale) + args=(0., expected_mean_isi.rescale( + t_stop.units).magnitude), + alternative='two-sided') + else: + refractory_period = refractory_period.rescale( + t_stop.units).item() + measured_rate = 1./expected_mean_isi.rescale( + t_stop.units).item() + effective_rate = measured_rate / ( + 1. - measured_rate * refractory_period) + + # Kolmogorov-Smirnov test + D, p = kstest( + intervals.rescale(t_stop.units).magnitude, + "expon", + # args are (loc, scale) + args=(refractory_period, 1./effective_rate), + alternative='two-sided') self.assertGreater(p, 0.001) self.assertLess(D, 0.12) def test_zero_refractory_period(self): rate = 10 * pq.Hz t_stop = 20 * pq.s + np.random.seed(27) - sp1 = stgen.homogeneous_poisson_process(rate, t_stop=t_stop, - as_array=True) + sp1 = stg.StationaryPoissonProcess( + rate, t_stop=t_stop).generate_spiketrain(as_array=True) + np.random.seed(27) - sp2 = stgen.homogeneous_poisson_process(rate, t_stop=t_stop, - refractory_period=0 * pq.ms, - as_array=True) + sp2 = stg.StationaryPoissonProcess( + rate, t_stop=t_stop, refractory_period=0. * pq.ms + ).generate_spiketrain( + as_array=True) + assert_array_almost_equal(sp1, sp2) def test_t_start_and_t_stop(self): rate = 10 * pq.Hz t_start = 17 * pq.ms t_stop = 2 * pq.s - for refractory_period in (None, 3 * pq.ms): - spiketrain = stgen.homogeneous_poisson_process( - rate=rate, t_start=t_start, t_stop=t_stop, - refractory_period=refractory_period) + + sp1 = stg.StationaryPoissonProcess( + rate, t_start=t_start, t_stop=t_stop).generate_spiketrain() + + sp2 = stg.StationaryPoissonProcess( + rate, t_start=t_start, t_stop=t_stop, refractory_period=3 * pq.ms + ).generate_spiketrain() + + for spiketrain in (sp1, sp2): self.assertEqual(spiketrain.t_start, t_start) self.assertEqual(spiketrain.t_stop, t_stop) @@ -222,17 +257,18 @@ def test_zero_rate(self): warnings.simplefilter("ignore") # RuntimeWarning: divide by zero encountered in true_divide # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - sp = stgen.homogeneous_poisson_process( + spiketrain = stg.StationaryPoissonProcess( rate=0 * pq.Hz, t_stop=10 * pq.s, - refractory_period=refractory_period) - self.assertEqual(sp.size, 0) + refractory_period=refractory_period).generate_spiketrain() + self.assertEqual(spiketrain.size, 0) def test_nondecrease_spike_times(self): for refractory_period in (None, 3 * pq.ms): np.random.seed(27) - spiketrain = stgen.homogeneous_poisson_process( + + spiketrain = stg.StationaryPoissonProcess( rate=10 * pq.Hz, t_stop=1000 * pq.s, - refractory_period=refractory_period) + refractory_period=refractory_period).generate_spiketrain() diffs = np.diff(spiketrain.times) self.assertTrue((diffs >= 0).all()) @@ -240,14 +276,13 @@ def test_compare_with_as_array(self): rate = 10 * pq.Hz t_stop = 10 * pq.s for refractory_period in (None, 3 * pq.ms): - np.random.seed(27) - spiketrain = stgen.homogeneous_poisson_process( + process = stg.StationaryPoissonProcess( rate=rate, t_stop=t_stop, refractory_period=refractory_period) + np.random.seed(27) + spiketrain = process.generate_spiketrain() self.assertIsInstance(spiketrain, neo.SpikeTrain) np.random.seed(27) - spiketrain_array = stgen.homogeneous_poisson_process( - rate=rate, t_stop=t_stop, refractory_period=refractory_period, - as_array=True) + spiketrain_array = process.generate_spiketrain().as_array() # don't check with isinstance: Quantity is a subclass of np.ndarray self.assertTrue(isinstance(spiketrain_array, np.ndarray)) assert_array_almost_equal(spiketrain.times.magnitude, @@ -257,9 +292,10 @@ def test_effective_rate_refractory_period(self): np.random.seed(27) rate_expected = 10 * pq.Hz refractory_period = 90 * pq.ms # 10 ms of effective ISI - spiketrain = stgen.homogeneous_poisson_process( - rate_expected, t_stop=1000 * pq.s, - refractory_period=refractory_period) + spiketrain = stg.StationaryPoissonProcess( + rate_expected, t_stop=1000 * pq.s, + refractory_period=refractory_period + ).generate_spiketrain() rate_obtained = len(spiketrain) / spiketrain.t_stop rate_obtained = rate_obtained.simplified self.assertAlmostEqual(rate_expected.simplified, @@ -273,132 +309,339 @@ def test_invalid(self): rate = 10 * pq.Hz for refractory_period in (None, 3 * pq.ms): # t_stop < t_start - hpp = stgen.homogeneous_poisson_process + + hpp = stg.StationaryPoissonProcess self.assertRaises( ValueError, hpp, rate=rate, t_start=5 * pq.ms, t_stop=1 * pq.ms, refractory_period=refractory_period) - # no units provided for rate, t_stop self.assertRaises(ValueError, hpp, rate=10, refractory_period=refractory_period) self.assertRaises(ValueError, hpp, rate=rate, t_stop=5, refractory_period=refractory_period) + # no units provided for refractory_period + self.assertRaises(ValueError, hpp, rate=rate, refractory_period=2) + self.assertRaises(ValueError, stg.StationaryPoissonProcess, + rate, refractory_period=1. * pq.s) - # no units provided for refractory_period - self.assertRaises(ValueError, hpp, rate=rate, refractory_period=2) +class StationaryGammaProcessTestCase(unittest.TestCase): -class InhomogeneousGammaTestCase(unittest.TestCase): - def setUp(self): - rate_list = [[20]] * 1000 + [[200]] * 1000 - self.rate_profile = neo.AnalogSignal( - rate_list * pq.Hz, sampling_period=0.001 * pq.s) - rate_0 = [[0]] * 1000 - self.rate_profile_0 = neo.AnalogSignal( - rate_0 * pq.Hz, sampling_period=0.001 * pq.s) - rate_negative = [[-1]] * 1000 - self.rate_profile_negative = neo.AnalogSignal( - rate_negative * pq.Hz, sampling_period=0.001 * pq.s) + def test_statistics(self): + # This is a statistical test that has a non-zero chance of failure + # during normal operation. Thus, we set the random seed to a value that + # creates a realization passing the test. + a = 3.0 + for b in (67.0 * pq.Hz, 0.067 * pq.kHz): + for t_stop in (2345 * pq.ms, 2.345 * pq.s): + np.random.seed(seed=12345) + spiketrain_old = stg.homogeneous_gamma_process( + a, b, t_stop=t_stop) + np.random.seed(seed=12345) + spiketrain = stg.StationaryGammaProcess( + rate=b/a, shape_factor=a, t_stop=t_stop, + equilibrium=False + ).generate_spiketrain() + assert_allclose(spiketrain_old.magnitude, spiketrain.magnitude) + + intervals = isi(spiketrain) + + expected_spike_count = int((b / a * t_stop).simplified) + # should fail about 1 time in 1000 + self.assertLess( + pdiff(expected_spike_count, spiketrain.size), 0.25) + + expected_mean_isi = (a / b).rescale(pq.ms) + self.assertLess( + pdiff(expected_mean_isi, intervals.mean()), 0.3) + + expected_first_spike = 0 * pq.ms + self.assertLess( + spiketrain[0] - expected_first_spike, + 4 * expected_mean_isi) + + expected_last_spike = t_stop + self.assertLess(expected_last_spike - + spiketrain[-1], 4 * expected_mean_isi) + + # Kolmogorov-Smirnov test + D, p = kstest(intervals.rescale(t_stop.units), + "gamma", + # args are (a, loc, scale) + args=(a, 0, (1 / b).rescale(t_stop.units)), + alternative='two-sided') + self.assertGreater(p, 0.001) + self.assertLess(D, 0.25) + + def test_compare_with_as_array(self): + a = 3. + b = 10 * pq.Hz + np.random.seed(27) + spiketrain = stg.StationaryGammaProcess( + rate=b/a, shape_factor=a, equilibrium=False).generate_spiketrain() + self.assertIsInstance(spiketrain, neo.SpikeTrain) + np.random.seed(27) + spiketrain_array = stg.StationaryGammaProcess( + rate=b / a, shape_factor=a, equilibrium=False).generate_spiketrain( + as_array=True) + # don't check with isinstance: pq.Quantity is a subclass of np.ndarray + self.assertTrue(isinstance(spiketrain_array, np.ndarray)) + assert_array_almost_equal(spiketrain.times.magnitude, spiketrain_array) + + +class StationaryLogNormalProcessTestCase(unittest.TestCase): def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. - np.random.seed(seed=12345) + sigma = 1.2 + for rate in (67.0 * pq.Hz, 0.067 * pq.kHz): + for t_stop in (2345 * pq.ms, 2.345 * pq.s): + np.random.seed(seed=123456) + spiketrain = stg.StationaryLogNormalProcess( + rate=rate, sigma=sigma, t_stop=t_stop, + equilibrium=False + ).generate_spiketrain() - shape_factor = 2.5 + intervals = isi(spiketrain) - for rate in [self.rate_profile, self.rate_profile.rescale(pq.kHz)]: - spiketrain = stgen.inhomogeneous_gamma_process( - rate, shape_factor=shape_factor) - intervals = isi(spiketrain) + expected_spike_count = int((rate * t_stop).simplified) + # should fail about 1 time in 1000 + self.assertLess( + pdiff(expected_spike_count, spiketrain.size), 0.25) - # Computing expected statistics and percentiles - expected_spike_count = (np.sum( - rate) * rate.sampling_period).simplified - percentile_count = poisson.ppf(.999, expected_spike_count) - expected_min_isi = (1 / np.min(rate)) - expected_max_isi = (1 / np.max(rate)) - percentile_min_isi = expon.ppf(.999, expected_min_isi) - percentile_max_isi = expon.ppf(.999, expected_max_isi) + expected_mean_isi = (1 / rate).rescale(pq.ms) + self.assertLess( + pdiff(expected_mean_isi, intervals.mean()), 0.3) - # Testing (each should fail 1 every 1000 times) - self.assertLess(spiketrain.size, percentile_count) - self.assertLess(np.min(intervals), percentile_min_isi) - self.assertLess(np.max(intervals), percentile_max_isi) + expected_first_spike = 0 * pq.ms + self.assertLess( + spiketrain[0] - expected_first_spike, + 4 * expected_mean_isi) - # Testing t_start t_stop - self.assertEqual(rate.t_stop, spiketrain.t_stop) - self.assertEqual(rate.t_start, spiketrain.t_start) + expected_last_spike = t_stop + self.assertLess(expected_last_spike - + spiketrain[-1], 4 * expected_mean_isi) - # Testing type - spiketrain_as_array = stgen.inhomogeneous_gamma_process( - rate, shape_factor=shape_factor, as_array=True) - self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) - self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) + # Kolmogorov-Smirnov test + D, p = kstest(intervals.rescale(t_stop.units), + "lognorm", + # args are (s, loc, scale) + args=(sigma, 0, + (1/rate * np.exp(- sigma**2/2) + ).rescale(t_stop.units)), + alternative='two-sided') + self.assertGreater(p, 0.001) + self.assertLess(D, 0.25) - # check error if rate has wrong format - self.assertRaises( - ValueError, stgen.inhomogeneous_gamma_process, - rate=[0.1, 2.], - shape_factor=shape_factor) + def test_compare_with_as_array(self): + sigma = 1.2 + rate = 10 * pq.Hz + np.random.seed(27) + spiketrain = stg.StationaryLogNormalProcess( + rate=rate, sigma=sigma, + equilibrium=False).generate_spiketrain() + self.assertIsInstance(spiketrain, neo.SpikeTrain) + np.random.seed(27) + spiketrain_array = stg.StationaryLogNormalProcess( + rate=rate, sigma=sigma, equilibrium=False + ).generate_spiketrain( + as_array=True) + # don't check with isinstance: pq.Quantity is a subclass of np.ndarray + self.assertTrue(isinstance(spiketrain_array, np.ndarray)) + assert_array_almost_equal(spiketrain.times.magnitude, spiketrain_array) - # check error if negative values in rate - self.assertRaises( - ValueError, stgen.inhomogeneous_gamma_process, - rate=neo.AnalogSignal([-0.1, 10.] * pq.Hz, - sampling_period=0.001 * pq.s), - shape_factor=shape_factor) - # check error if rate is empty - self.assertRaises( - ValueError, stgen.inhomogeneous_gamma_process, - rate=neo.AnalogSignal([] * pq.Hz, sampling_period=0.001 * pq.s), - shape_factor=shape_factor) +class StationaryInverseGaussianProcessTestCase(unittest.TestCase): - def test_recovered_firing_rate_profile(self): - np.random.seed(54) - t_start = 0 * pq.s - t_stop = 4 * np.round(np.pi, decimals=3) * pq.s # 2 full periods - sampling_period = 0.001 * pq.s + def test_statistics(self): + # This is a statistical test that has a non-zero chance of failure + # during normal operation. Thus, we set the random seed to a value that + # creates a realization passing the test. + cv = 0.9 + for rate in (67.0 * pq.Hz, 0.067 * pq.kHz): + for t_stop in (2345 * pq.ms, 2.345 * pq.s): + np.random.seed(seed=123456) + spiketrain = stg.StationaryInverseGaussianProcess( + rate=rate, cv=cv, t_stop=t_stop, equilibrium=False + ).generate_spiketrain() - # an arbitrary rate profile - profile = 0.5 * (1 + np.sin(np.arange(t_start.item(), t_stop.item(), - sampling_period.item()))) + intervals = isi(spiketrain) - time_generation = 0 - n_trials = 200 - rtol = 0.05 # 5% of deviation allowed - kernel = kernels.RectangularKernel(sigma=0.25 * pq.s) - for rate in (10 * pq.Hz, 100 * pq.Hz): - rate_profile = neo.AnalogSignal(rate * profile, - sampling_period=sampling_period) - # the recovered firing rate profile should not depend on the - # shape factor; here we test float and integer values of the shape - # factor: the method supports float values that is not trivial - # for inhomogeneous gamma process generation - for shape_factor in (1, 2.5, 10.): + expected_spike_count = int((rate * t_stop).simplified) + # should fail about 1 time in 1000 - spiketrains = \ - [stgen.inhomogeneous_gamma_process( - rate_profile, shape_factor=shape_factor) - for _ in range(n_trials)] - rate_recovered = instantaneous_rate( - spiketrains, - sampling_period=sampling_period, - kernel=kernel, - t_start=t_start, - t_stop=t_stop, trim=True).sum(axis=1) / n_trials + self.assertLess( + pdiff(expected_spike_count, spiketrain.size), 0.25) - rate_recovered = rate_recovered.flatten().magnitude - trim = (rate_profile.shape[0] - rate_recovered.shape[0]) // 2 - rate_profile_valid = rate_profile.magnitude.squeeze() - rate_profile_valid = rate_profile_valid[trim: -trim - 1] - assert_allclose(rate_recovered, rate_profile_valid, - rtol=0, atol=rtol * rate.item()) + expected_mean_isi = (1 / rate).rescale(pq.ms) + self.assertLess( + pdiff(expected_mean_isi, intervals.mean()), 0.3) + + expected_first_spike = 0 * pq.ms + self.assertLess( + spiketrain[0] - expected_first_spike, + 4 * expected_mean_isi) + + expected_last_spike = t_stop + self.assertLess(expected_last_spike - + spiketrain[-1], 4 * expected_mean_isi) + + # Kolmogorov-Smirnov test + D, p = kstest(intervals.rescale(t_stop.units), + "invgauss", + # args are (mu, loc, scale) + args=(cv**2, 0, + (1/(rate*cv**2)).rescale(t_stop.units)), + alternative='two-sided') + self.assertGreater(p, 0.001) + self.assertLess(D, 0.25) + + def test_compare_with_as_array(self): + cv = 1.2 + rate = 10 * pq.Hz + np.random.seed(27) + spiketrain = stg.StationaryInverseGaussianProcess( + rate=rate, cv=cv, equilibrium=False).generate_spiketrain() + self.assertIsInstance(spiketrain, neo.SpikeTrain) + np.random.seed(27) + spiketrain_array = stg.StationaryInverseGaussianProcess( + rate=rate, cv=cv, equilibrium=False).generate_spiketrain( + as_array=True) + # don't check with isinstance: pq.Quantity is a subclass of np.ndarray + self.assertTrue(isinstance(spiketrain_array, np.ndarray)) + assert_array_almost_equal(spiketrain.times.magnitude, spiketrain_array) -class InhomogeneousPoissonProcessTestCase(unittest.TestCase): +class FirstSpikeCvTestCase(unittest.TestCase): + def setUp(self): + np.random.seed(987654321) + self.rate = 100. * pq.Hz + self.t_stop = 10.*pq.s + self.n_spiketrains = 10 + + # can only have CV equal to 1. + self.poisson_process = stg.StationaryPoissonProcess( + rate=self.rate, + t_stop=self.t_stop) + + # choose all further processes to have CV of 1/2 + # CV = 1 - rate * refractory_period + self.poisson_refractory_period_ordinary = stg.StationaryPoissonProcess( + rate=self.rate, + refractory_period=0.5 / self.rate, + t_stop=self.t_stop, + equilibrium=False) + + self.poisson_refractory_period_equilibrium =\ + stg.StationaryPoissonProcess( + rate=self.rate, + refractory_period=0.5 / self.rate, + t_stop=self.t_stop, + equilibrium=True) + + # CV = 1 / sqrt(shape_factor) + self.gamma_process_ordinary = stg.StationaryGammaProcess( + rate=self.rate, + shape_factor=4, + t_stop=self.t_stop, + equilibrium=False) + + self.gamma_process_equilibrium = stg.StationaryGammaProcess( + rate=self.rate, + shape_factor=4, + t_stop=self.t_stop, + equilibrium=True) + + # CV = sqrt(exp(sigma**2) - 1) + self.log_normal_process_ordinary = stg.StationaryLogNormalProcess( + rate=self.rate, + sigma=np.sqrt(np.log(5./4.)), + t_stop=self.t_stop, + equilibrium=False) + + self.log_normal_process_equilibrium = stg.StationaryLogNormalProcess( + rate=self.rate, + sigma=np.sqrt(np.log(5. / 4.)), + t_stop=self.t_stop, + equilibrium=True) + + self.inverse_gaussian_process_ordinary = \ + stg.StationaryInverseGaussianProcess( + rate=self.rate, + cv=1/2, + t_stop=self.t_stop, + equilibrium=False) + + self.inverse_gaussian_process_equilibrium = \ + stg.StationaryInverseGaussianProcess( + rate=self.rate, + cv=1 / 2, + t_stop=self.t_stop, + equilibrium=True) + + def test_cv(self): + processes = (self.poisson_process, + self.poisson_refractory_period_ordinary, + self.gamma_process_ordinary, + self.log_normal_process_ordinary, + self.inverse_gaussian_process_ordinary) + for process in processes: + if process is self.poisson_process: + self.assertAlmostEqual(1., process.expected_cv) + + # test the general expected-cv function + self.assertAlmostEqual( + 1., super(type(process), process).expected_cv) + else: + self.assertAlmostEqual(0.5, process.expected_cv) + # test the general expected-cv function + self.assertAlmostEqual( + 0.5, super(type(process), process).expected_cv) + spiketrains = process.generate_n_spiketrains( + n_spiketrains=self.n_spiketrains, + as_array=True) + + cvs = [variation(np.diff(spiketrain)) + for spiketrain in spiketrains] + mean_cv = np.mean(cvs) + + assert_allclose( + process.expected_cv, mean_cv, atol=0.01) + + def test_first_spike(self): + ordinary_processes = (self.poisson_refractory_period_ordinary, + self.gamma_process_ordinary, + self.log_normal_process_ordinary, + self.inverse_gaussian_process_ordinary) + equilibrium_processes = (self.poisson_refractory_period_equilibrium, + self.gamma_process_equilibrium, + self.log_normal_process_equilibrium, + self.inverse_gaussian_process_equilibrium) + + for ordinary_process, equilibrium_process in zip( + ordinary_processes, equilibrium_processes): + ordinary_spiketrains = ordinary_process.generate_n_spiketrains( + self.n_spiketrains) + equilbrium_spiketrains = \ + equilibrium_process.generate_n_spiketrains( + self.n_spiketrains) + first_spikes_ordinary = [spiketrain[0].item() + for spiketrain in ordinary_spiketrains] + first_spikes_equilibrium = \ + [spiketrain[0].item() + for spiketrain in equilbrium_spiketrains] + mean_first_spike_ordinary = np.mean(first_spikes_ordinary) + mean_first_spike_equilibrium = np.mean(first_spikes_equilibrium) + + # for regular spike trains (CV=0.5 here) the first spike + # in equilibrium is on average than in the ordinary case + self.assertLess(mean_first_spike_equilibrium, + mean_first_spike_ordinary) + + +class NonStationaryPoissonProcessTestCase(unittest.TestCase): def setUp(self): rate_list = [[20]] * 1000 + [[200]] * 1000 self.rate_profile = neo.AnalogSignal( @@ -414,12 +657,20 @@ def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. - np.random.seed(seed=12345) - for rate in (self.rate_profile, self.rate_profile.rescale(pq.kHz)): for refractory_period in (3 * pq.ms, None): - spiketrain = stgen.inhomogeneous_poisson_process( + np.random.seed(seed=12345) + spiketrain_old = stg.inhomogeneous_poisson_process( rate, refractory_period=refractory_period) + np.random.seed(seed=12345) + + process = stg.NonStationaryPoissonProcess + spiketrain = process(rate, refractory_period=refractory_period + ).generate_spiketrain() + + assert_allclose( + spiketrain_old.magnitude, spiketrain.magnitude) + intervals = isi(spiketrain) # Computing expected statistics and percentiles @@ -445,23 +696,24 @@ def test_statistics(self): self.assertEqual(rate.t_start, spiketrain.t_start) # Testing type - spiketrain_as_array = stgen.inhomogeneous_poisson_process( - rate, as_array=True) + spiketrain_as_array = stg.NonStationaryPoissonProcess( + rate).generate_spiketrain(as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) # Testing type for refractory period refractory_period = 3 * pq.ms - spiketrain = stgen.inhomogeneous_poisson_process( - rate, refractory_period=refractory_period) - spiketrain_as_array = stgen.inhomogeneous_poisson_process( - rate, as_array=True, refractory_period=refractory_period) + spiketrain = stg.NonStationaryPoissonProcess( + rate, refractory_period=refractory_period).generate_spiketrain() + spiketrain_as_array = stg.NonStationaryPoissonProcess( + rate, refractory_period=refractory_period).generate_spiketrain( + as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) # Check that to high refractory period raises error self.assertRaises( - ValueError, stgen.inhomogeneous_poisson_process, + ValueError, stg.NonStationaryPoissonProcess, self.rate_profile, refractory_period=1000 * pq.ms) @@ -471,11 +723,12 @@ def test_effective_rate_refractory_period(self): refractory_period = 90 * pq.ms # 10 ms of effective ISI rates = neo.AnalogSignal(np.repeat(rate_expected, 1000), units=pq.Hz, t_start=0 * pq.ms, sampling_rate=1 * pq.Hz) - spiketrain = stgen.inhomogeneous_poisson_process( - rates, refractory_period=refractory_period) + spiketrain = stg.NonStationaryPoissonProcess( + rates, refractory_period=refractory_period).generate_spiketrain() rate_obtained = len(spiketrain) / spiketrain.t_stop - self.assertAlmostEqual(rate_expected, rate_obtained.simplified, - places=1) + self.assertAlmostEqual( + rate_expected.simplified.item(), + rate_obtained.simplified.item(), places=1) intervals_inhomo = isi(spiketrain) isi_mean_expected = 1. / rate_expected self.assertAlmostEqual(isi_mean_expected.simplified, @@ -484,79 +737,139 @@ def test_effective_rate_refractory_period(self): def test_zero_rate(self): for refractory_period in (3 * pq.ms, None): - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - # RuntimeWarning: divide by zero encountered in true_divide - # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - spiketrain = stgen.inhomogeneous_poisson_process( - self.rate_profile_0, refractory_period=refractory_period) + + process = stg.NonStationaryPoissonProcess + spiketrain = process( + self.rate_profile_0, refractory_period=refractory_period + ).generate_spiketrain() self.assertEqual(spiketrain.size, 0) + self.assertRaises( + ValueError, stg.NonStationaryPoissonProcess, + self.rate_profile, refractory_period=5) def test_negative_rates(self): for refractory_period in (3 * pq.ms, None): + process = stg.NonStationaryPoissonProcess self.assertRaises( - ValueError, stgen.inhomogeneous_poisson_process, + ValueError, process, self.rate_profile_negative, refractory_period=refractory_period) -class HomogeneousGammaProcessTestCase(unittest.TestCase): +class NonStationaryGammaTestCase(unittest.TestCase): + def setUp(self): + rate_list = [[20]] * 1000 + [[200]] * 1000 + self.rate_profile = neo.AnalogSignal( + rate_list * pq.Hz, sampling_period=0.001 * pq.s) + rate_0 = [[0]] * 1000 + self.rate_profile_0 = neo.AnalogSignal( + rate_0 * pq.Hz, sampling_period=0.001 * pq.s) + rate_negative = [[-1]] * 1000 + self.rate_profile_negative = neo.AnalogSignal( + rate_negative * pq.Hz, sampling_period=0.001 * pq.s) def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. - np.random.seed(seed=12345) + shape_factor = 2.5 - a = 3.0 - for b in (67.0 * pq.Hz, 0.067 * pq.kHz): - for t_stop in (2345 * pq.ms, 2.345 * pq.s): - spiketrain = stgen.homogeneous_gamma_process( - a, b, t_stop=t_stop) - intervals = isi(spiketrain) + for rate in [self.rate_profile, self.rate_profile.rescale(pq.kHz)]: + np.random.seed(seed=12345) + spiketrain_old = stg.inhomogeneous_gamma_process( + rate, shape_factor=shape_factor) + np.random.seed(seed=12345) + spiketrain = stg.NonStationaryGammaProcess( + rate, shape_factor=shape_factor).generate_spiketrain() + assert_allclose(spiketrain_old.magnitude, spiketrain.magnitude) - expected_spike_count = int((b / a * t_stop).simplified) - # should fail about 1 time in 1000 - self.assertLess( - pdiff(expected_spike_count, spiketrain.size), 0.25) + intervals = isi(spiketrain) - expected_mean_isi = (a / b).rescale(pq.ms) - self.assertLess( - pdiff(expected_mean_isi, intervals.mean()), 0.3) + # Computing expected statistics and percentiles + expected_spike_count = (np.sum( + rate) * rate.sampling_period).simplified + percentile_count = poisson.ppf(.999, expected_spike_count) + expected_min_isi = (1 / np.min(rate)) + expected_max_isi = (1 / np.max(rate)) + percentile_min_isi = expon.ppf(.999, expected_min_isi) + percentile_max_isi = expon.ppf(.999, expected_max_isi) - expected_first_spike = 0 * pq.ms - self.assertLess( - spiketrain[0] - expected_first_spike, - 4 * expected_mean_isi) + # Testing (each should fail 1 every 1000 times) + self.assertLess(spiketrain.size, percentile_count) + self.assertLess(np.min(intervals), percentile_min_isi) + self.assertLess(np.max(intervals), percentile_max_isi) - expected_last_spike = t_stop - self.assertLess(expected_last_spike - - spiketrain[-1], 4 * expected_mean_isi) + # Testing t_start t_stop + self.assertEqual(rate.t_stop, spiketrain.t_stop) + self.assertEqual(rate.t_start, spiketrain.t_start) - # Kolmogorov-Smirnov test - D, p = kstest(intervals.rescale(t_stop.units), - "gamma", - # args are (a, loc, scale) - args=(a, 0, (1 / b).rescale(t_stop.units)), - alternative='two-sided') - self.assertGreater(p, 0.001) - self.assertLess(D, 0.25) + # Testing type + spiketrain_as_array = stg.NonStationaryGammaProcess( + rate, shape_factor=shape_factor).generate_spiketrain( + as_array=True) + self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) + self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) - def test_compare_with_as_array(self): - a = 3. - b = 10 * pq.Hz - np.random.seed(27) - spiketrain = stgen.homogeneous_gamma_process(a=a, b=b) - self.assertIsInstance(spiketrain, neo.SpikeTrain) - np.random.seed(27) - spiketrain_array = stgen.homogeneous_gamma_process(a=a, b=b, - as_array=True) - # don't check with isinstance: pq.Quantity is a subclass of np.ndarray - self.assertTrue(isinstance(spiketrain_array, np.ndarray)) - assert_array_almost_equal(spiketrain.times.magnitude, spiketrain_array) + # check error if rate has wrong format + self.assertRaises( + ValueError, stg.NonStationaryGammaProcess, + rate_signal=[0.1, 2.], + shape_factor=shape_factor) + + # check error if negative values in rate + self.assertRaises( + ValueError, stg.NonStationaryGammaProcess, + rate_signal=neo.AnalogSignal( + [-0.1, 10.] * pq.Hz, sampling_period=0.001 * pq.s), + shape_factor=shape_factor) + + # check error if rate is empty + self.assertRaises( + ValueError, stg.NonStationaryGammaProcess, + rate_signal=neo.AnalogSignal( + [] * pq.Hz, sampling_period=0.001 * pq.s), + shape_factor=shape_factor) + + def test_recovered_firing_rate_profile(self): + np.random.seed(54) + t_start = 0 * pq.s + t_stop = 2 * np.round(np.pi, decimals=3) * pq.s # 2 full periods + sampling_period = 0.001 * pq.s + + # an arbitrary rate profile + profile = 0.5 * (1 + np.sin(np.arange(t_start.item(), t_stop.item(), + sampling_period.item()))) + + n_trials = 100 + rtol = 0.1 # 10% of deviation allowed + kernel = kernels.RectangularKernel(sigma=0.25 * pq.s) + for rate in (10 * pq.Hz, 50 * pq.Hz): + rate_profile = neo.AnalogSignal(rate * profile, + sampling_period=sampling_period) + # the recovered firing rate profile should not depend on the + # shape factor; here we test float and integer values of the shape + # factor: the method supports float values that is not trivial + # for inhomogeneous gamma process generation + for shape_factor in (2.5, 10.): + spiketrains = stg.NonStationaryGammaProcess( + rate_profile, shape_factor=shape_factor + ).generate_n_spiketrains(n_trials) + rate_recovered = instantaneous_rate( + spiketrains, + sampling_period=sampling_period, + kernel=kernel, + t_start=t_start, + t_stop=t_stop, trim=True).sum(axis=1) / n_trials + + rate_recovered = rate_recovered.flatten().magnitude + trim = (rate_profile.shape[0] - rate_recovered.shape[0]) // 2 + rate_profile_valid = rate_profile.magnitude.squeeze() + rate_profile_valid = rate_profile_valid[trim: -trim - 1] + assert_allclose(rate_recovered, rate_profile_valid, + rtol=0, atol=rtol * rate.item()) -class _n_poisson_TestCase(unittest.TestCase): +class NPoissonTestCase(unittest.TestCase): def setUp(self): self.n = 4 @@ -567,7 +880,7 @@ def setUp(self): def test_poisson(self): # Check the output types for input rate + n number of neurons - pp = stgen._n_poisson( + pp = stg._n_poisson( rate=self.rate, t_stop=self.t_stop, n_spiketrains=self.n) @@ -577,7 +890,7 @@ def test_poisson(self): self.assertEqual(len(pp), self.n) # Check the output types for input list of rates - pp = stgen._n_poisson(rate=self.rates, t_stop=self.t_stop) + pp = stg._n_poisson(rate=self.rates, t_stop=self.t_stop) self.assertIsInstance(pp, list) self.assertIsInstance(pp[0], neo.core.spiketrain.SpikeTrain) self.assertEqual(pp[0].simplified.units, 1000 * pq.ms) @@ -587,25 +900,25 @@ def test_poisson_error(self): # Dimensionless rate self.assertRaises( - ValueError, stgen._n_poisson, rate=5, t_stop=self.t_stop) + ValueError, stg._n_poisson, rate=5, t_stop=self.t_stop) # Negative rate self.assertRaises( - ValueError, stgen._n_poisson, rate=-5 * pq.Hz, t_stop=self.t_stop) + ValueError, stg._n_poisson, rate=-5 * pq.Hz, t_stop=self.t_stop) # Negative value when rate is a list self.assertRaises( - ValueError, stgen._n_poisson, rate=[-5, 3] * pq.Hz, + ValueError, stg._n_poisson, rate=[-5, 3] * pq.Hz, t_stop=self.t_stop) # Negative n self.assertRaises( - ValueError, stgen._n_poisson, rate=self.rate, t_stop=self.t_stop, + ValueError, stg._n_poisson, rate=self.rate, t_stop=self.t_stop, n_spiketrains=-1) # t_start>t_stop self.assertRaises( - ValueError, stgen._n_poisson, rate=self.rate, t_start=4 * pq.ms, + ValueError, stg._n_poisson, rate=self.rate, t_start=4 * pq.ms, t_stop=3 * pq.ms, n_spiketrains=3) -class singleinteractionprocess_TestCase(unittest.TestCase): +class SingleInteractionProcessTestCase(unittest.TestCase): def setUp(self): self.n = 4 self.rate = 10 * pq.Hz @@ -613,14 +926,7 @@ def setUp(self): self.t_stop = 10000 * pq.ms self.rate_c = 1 * pq.Hz - def test_sip(self): - - # Generate an example SIP mode - sip, coinc = stgen.single_interaction_process( - n_spiketrains=self.n, t_stop=self.t_stop, rate=self.rate, - coincidence_rate=self.rate_c, return_coincidences=True) - - # Check the output types + def format_check(self, sip, coinc): self.assertEqual(type(sip), list) self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain) self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain) @@ -629,31 +935,34 @@ def test_sip(self): # Check the output length self.assertEqual(len(sip), self.n) + + def test_sip(self): + + # Generate an example SIP mode + sip, coinc = stg.single_interaction_process( + n_spiketrains=self.n, t_stop=self.t_stop, rate=self.rate, + coincidence_rate=self.rate_c, return_coincidences=True) + + # Check the output types + self.format_check(sip, coinc) self.assertEqual( len(coinc[0]), (self.rate_c * self.t_stop).simplified.magnitude) with warnings.catch_warnings(): warnings.simplefilter("ignore") # Generate an example SIP mode giving a list of rates as imput - sip, coinc = stgen.single_interaction_process( + sip, coinc = stg.single_interaction_process( t_stop=self.t_stop, rate=self.rates, coincidence_rate=self.rate_c, return_coincidences=True) # Check the output types - self.assertEqual(type(sip), list) - self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain) - self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain) - self.assertEqual(sip[0].simplified.units, 1000 * pq.ms) - self.assertEqual(coinc[0].simplified.units, 1000 * pq.ms) - - # Check the output length - self.assertEqual(len(sip), self.n) + self.format_check(sip, coinc) self.assertEqual( len(coinc[0]), (self.rate_c * self.t_stop).rescale(pq.dimensionless)) # Generate an example SIP mode stochastic number of coincidences - sip = stgen.single_interaction_process( + sip = stg.single_interaction_process( n_spiketrains=self.n, t_stop=self.t_stop, rate=self.rate, @@ -669,63 +978,67 @@ def test_sip(self): def test_sip_error(self): # Negative rate self.assertRaises( - ValueError, stgen.single_interaction_process, n_spiketrains=self.n, + ValueError, stg.single_interaction_process, n_spiketrains=self.n, rate=-5 * pq.Hz, coincidence_rate=self.rate_c, t_stop=self.t_stop) # Negative coincidence rate self.assertRaises( - ValueError, stgen.single_interaction_process, n_spiketrains=self.n, + ValueError, stg.single_interaction_process, n_spiketrains=self.n, rate=self.rate, coincidence_rate=-3 * pq.Hz, t_stop=self.t_stop) # Negative value when rate is a list self.assertRaises( - ValueError, stgen.single_interaction_process, n_spiketrains=self.n, + ValueError, stg.single_interaction_process, n_spiketrains=self.n, rate=[-5, 3, 4, 2] * pq.Hz, coincidence_rate=self.rate_c, t_stop=self.t_stop) # Negative n self.assertRaises( - ValueError, stgen.single_interaction_process, n_spiketrains=-1, + ValueError, stg.single_interaction_process, n_spiketrains=-1, rate=self.rate, coincidence_rate=self.rate_c, t_stop=self.t_stop) # Rate_c < rate self.assertRaises( ValueError, - stgen.single_interaction_process, + stg.single_interaction_process, n_spiketrains=self.n, rate=self.rate, coincidence_rate=self.rate + 1 * pq.Hz, t_stop=self.t_stop) -class cppTestCase(unittest.TestCase): +class CppTestCase(unittest.TestCase): + + def format_check(self, cpp, amplitude_distribution, t_start, t_stop): + self.assertEqual( + [type(train) for train in cpp], + [neo.SpikeTrain] * len(cpp)) + self.assertEqual(cpp[0].simplified.units, 1000 * pq.ms) + self.assertEqual(type(cpp), list) + # testing quantities format of the output + self.assertEqual( + [train.simplified.units for train in cpp], + [1000 * pq.ms] * len(cpp)) + # testing output t_start t_stop + for spiketrain in cpp: + self.assertEqual(spiketrain.t_stop, t_stop) + self.assertEqual(spiketrain.t_start, t_start) + self.assertEqual(len(cpp), len(amplitude_distribution) - 1) + def test_cpp_hom(self): # testing output with generic inputs amplitude_distribution = np.array([0, .9, .1]) t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 3 * pq.Hz - cpp_hom = stgen.cpp(rate, amplitude_distribution, - t_stop, t_start=t_start) - # testing the ouput formats - self.assertEqual( - [type(train) for train in cpp_hom], - [neo.SpikeTrain] * len(cpp_hom)) - self.assertEqual(cpp_hom[0].simplified.units, 1000 * pq.ms) - self.assertEqual(type(cpp_hom), list) - # testing quantities format of the output - self.assertEqual( - [train.simplified.units for train in cpp_hom], - [1000 * pq.ms] * len(cpp_hom)) - # testing output t_start t_stop - for st in cpp_hom: - self.assertEqual(st.t_stop, t_stop) - self.assertEqual(st.t_start, t_start) - self.assertEqual(len(cpp_hom), len(amplitude_distribution) - 1) + cpp_hom = stg.cpp(rate, amplitude_distribution, + t_stop, t_start=t_start) + # testing the output formats + self.format_check(cpp_hom, amplitude_distribution, t_start, t_stop) # testing the units t_stop = 10000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 3 * pq.Hz - cpp_unit = stgen.cpp(rate, amplitude_distribution, - t_stop, t_start=t_start) + cpp_unit = stg.cpp(rate, amplitude_distribution, + t_stop, t_start=t_start) self.assertEqual(cpp_unit[0].units, t_stop.units) self.assertEqual(cpp_unit[0].t_stop.units, t_stop.units) @@ -736,7 +1049,7 @@ def test_cpp_hom(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 3 * pq.Hz - cpp_hom_empty = stgen.cpp( + cpp_hom_empty = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertEqual( @@ -747,7 +1060,7 @@ def test_cpp_hom(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 0 * pq.Hz - cpp_hom_empty_r = stgen.cpp( + cpp_hom_empty_r = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertEqual( [len(train) for train in cpp_hom_empty_r], [0] * len( @@ -758,7 +1071,7 @@ def test_cpp_hom(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 3 * pq.Hz - cpp_hom_eq = stgen.cpp( + cpp_hom_eq = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertTrue( @@ -769,7 +1082,7 @@ def test_cpp_hom_errors(self): # testing empty amplitude self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[], t_stop=10 * 1000 * pq.ms, rate=3 * pq.Hz) @@ -777,13 +1090,13 @@ def test_cpp_hom_errors(self): # testing sum of amplitude>1 self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[1, 1, 1], t_stop=10 * 1000 * pq.ms, rate=3 * pq.Hz) # testing negative value in the amplitude self.assertRaises( - ValueError, stgen.cpp, amplitude_distribution=[-1, 1, 1], + ValueError, stg.cpp, amplitude_distribution=[-1, 1, 1], t_stop=10 * 1000 * pq.ms, rate=3 * pq.Hz) # test negative rate @@ -792,13 +1105,13 @@ def test_cpp_hom_errors(self): # Catches RuntimeWarning: invalid value encountered in sqrt # number = np.ceil(n + 3 * np.sqrt(n)), when `n` == -3 Hz. self.assertRaises( - ValueError, stgen.cpp, amplitude_distribution=[0, 1, 0], + ValueError, stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=-3 * pq.Hz) # test wrong unit for rate self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=3 * 1000 * pq.ms) @@ -806,19 +1119,19 @@ def test_cpp_hom_errors(self): # testing raises of AttributeError (missing input units) # Testing missing unit to t_stop self.assertRaises( - ValueError, stgen.cpp, amplitude_distribution=[0, 1, 0], t_stop=10, + ValueError, stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10, rate=3 * pq.Hz) # Testing missing unit to t_start self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=3 * pq.Hz, t_start=3) # testing rate missing unit self.assertRaises( - AttributeError, stgen.cpp, amplitude_distribution=[0, 1, 0], + AttributeError, stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=3) @@ -832,31 +1145,17 @@ def test_cpp_het(self): warnings.simplefilter("ignore") # Catch RuntimeWarning: divide by zero encountered in true_divide # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. - cpp_het = stgen.cpp(rate, amplitude_distribution, - t_stop, t_start=t_start) - # testing the ouput formats - self.assertEqual( - [type(train) for train in cpp_het], - [neo.SpikeTrain] * len(cpp_het)) - self.assertEqual(cpp_het[0].simplified.units, 1000 * pq.ms) - self.assertEqual(type(cpp_het), list) - # testing units - self.assertEqual( - [train.simplified.units for train in cpp_het], - [1000 * pq.ms] * len(cpp_het)) - # testing output t_start and t_stop - for st in cpp_het: - self.assertEqual(st.t_stop, t_stop) - self.assertEqual(st.t_start, t_start) - # testing the number of output spiketrains - self.assertEqual(len(cpp_het), len(amplitude_distribution) - 1) + cpp_het = stg.cpp(rate, amplitude_distribution, + t_stop, t_start=t_start) + # testing the output formats + self.format_check(cpp_het, amplitude_distribution, t_start, t_stop) self.assertEqual(len(cpp_het), len(rate)) # testing the units t_stop = 10000 * pq.ms t_start = 5 * 1000 * pq.ms rate = [3, 4] * pq.Hz - cpp_unit = stgen.cpp( + cpp_unit = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertEqual(cpp_unit[0].units, t_stop.units) @@ -867,7 +1166,7 @@ def test_cpp_het(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = [3, 4] * pq.Hz - cpp_het_empty = stgen.cpp( + cpp_het_empty = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertEqual(len(cpp_het_empty[0]), 0) @@ -877,18 +1176,18 @@ def test_cpp_het(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = [0, 0] * pq.Hz - cpp_het_empty_r = stgen.cpp( + cpp_het_empty_r = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertEqual( [len(train) for train in cpp_het_empty_r], [0] * len( cpp_het_empty_r)) - # testing completely sync spiketrains + # testing completely synchronous spike trains amplitude_distribution = np.array([0, 0, 1]) t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = [3, 3] * pq.Hz - cpp_het_eq = stgen.cpp( + cpp_het_eq = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start) self.assertTrue(np.allclose( @@ -899,57 +1198,57 @@ def test_cpp_het_err(self): # testing empty amplitude self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz) # testing sum amplitude>1 self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[1, 1, 1], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz) # testing amplitude negative value self.assertRaises( - ValueError, stgen.cpp, amplitude_distribution=[-1, 1, 1], + ValueError, stg.cpp, amplitude_distribution=[-1, 1, 1], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz) # testing negative rate - self.assertRaises(ValueError, stgen.cpp, amplitude_distribution=[ + self.assertRaises(ValueError, stg.cpp, amplitude_distribution=[ 0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=[-3, 4] * pq.Hz) # testing empty rate self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=[] * pq.Hz) # testing empty amplitude self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz) # testing different len(A)-1 and len(rate) self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz) # testing rate with different unit from Hz self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * 1000 * pq.ms) # Testing analytical constrain between amplitude and rate self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 0, 1], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz, @@ -958,19 +1257,19 @@ def test_cpp_het_err(self): # testing raises of AttributeError (missing input units) # Testing missing unit to t_stop self.assertRaises( - ValueError, stgen.cpp, amplitude_distribution=[0, 1, 0], t_stop=10, + ValueError, stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10, rate=[3, 4] * pq.Hz) # Testing missing unit to t_start self.assertRaises( ValueError, - stgen.cpp, + stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=[3, 4] * pq.Hz, t_start=3) # Testing missing unit to rate self.assertRaises( - AttributeError, stgen.cpp, amplitude_distribution=[0, 1, 0], + AttributeError, stg.cpp, amplitude_distribution=[0, 1, 0], t_stop=10 * 1000 * pq.ms, rate=[3, 4]) @@ -980,44 +1279,14 @@ def test_cpp_jttered(self): t_stop = 10 * 1000 * pq.ms t_start = 5 * 1000 * pq.ms rate = 3 * pq.Hz - cpp_shift = stgen.cpp( + cpp_shift = stg.cpp( rate, amplitude_distribution, t_stop, t_start=t_start, shift=3 * pq.ms) - # testing the ouput formats - self.assertEqual( - [type(train) for train in cpp_shift], [neo.SpikeTrain] * len( - cpp_shift)) - self.assertEqual(cpp_shift[0].simplified.units, 1000 * pq.ms) - self.assertEqual(type(cpp_shift), list) - # testing quantities format of the output - self.assertEqual( - [train.simplified.units for train in cpp_shift], - [1000 * pq.ms] * len(cpp_shift)) - # testing output t_start t_stop - for spiketrain in cpp_shift: - self.assertEqual(spiketrain.t_stop, t_stop) - self.assertEqual(spiketrain.t_start, t_start) - self.assertEqual(len(cpp_shift), len(amplitude_distribution) - 1) - - -class HomogeneousPoissonProcessWithRefrPeriodTestCase(unittest.TestCase): - - def test_invalid(self): - rate = 10 * pq.Hz - # t_stop < t_start - hpp = stgen.homogeneous_poisson_process - self.assertRaises(ValueError, hpp, rate=rate, t_start=5 * pq.ms, - t_stop=1 * pq.ms, refractory_period=3 * pq.ms) - - # no units provided - self.assertRaises(ValueError, hpp, rate=10, - refractory_period=3 * pq.ms) - self.assertRaises(ValueError, hpp, rate=rate, t_stop=5, - refractory_period=3 * pq.ms) - self.assertRaises(ValueError, hpp, rate=rate, refractory_period=2) + # testing the output formats + self.format_check(cpp_shift, amplitude_distribution, t_start, t_stop) if __name__ == '__main__': diff --git a/elephant/test/test_spike_train_surrogates.py b/elephant/test/test_spike_train_surrogates.py index e8447b070..cca6174cb 100644 --- a/elephant/test/test_spike_train_surrogates.py +++ b/elephant/test/test_spike_train_surrogates.py @@ -451,7 +451,8 @@ def test_joint_isi_dithering_format(self): rate = 100. * pq.Hz t_stop = 1. * pq.s - spiketrain = stg.homogeneous_poisson_process(rate, t_stop=t_stop) + process = stg.StationaryPoissonProcess(rate, t_stop=t_stop) + spiketrain = process.generate_spiketrain() n_surrogates = 2 dither = 10 * pq.ms @@ -540,13 +541,12 @@ def test_joint_isi_dithering_empty_train(self): self.assertEqual(len(surrogate_train), 0) def test_joint_isi_dithering_output(self): - spiketrain = stg.homogeneous_poisson_process( - rate=100. * pq.Hz, - refractory_period=3 * pq.ms, - t_stop=0.1 * pq.s) + process = stg.StationaryPoissonProcess( + rate=100. * pq.Hz, refractory_period=3 * pq.ms, t_stop=0.1 * pq.s) + spiketrain = process.generate_spiketrain() surrogate_train = surr.JointISI(spiketrain).dithering()[0] - ground_truth = [0.005571, 0.018363, 0.026825, 0.036336, 0.045193, - 0.05146, 0.058489, 0.078053] + ground_truth = [0.0060744, 0.01886591, 0.02732847, 0.03683888, + 0.04569622, 0.05196334, 0.05899197, 0.07855664] assert_array_almost_equal(surrogate_train.magnitude, ground_truth) def test_joint_isi_with_wrongly_ordered_spikes(self): diff --git a/elephant/test/test_spike_train_synchrony.py b/elephant/test/test_spike_train_synchrony.py index 08e981163..806abcf5c 100644 --- a/elephant/test/test_spike_train_synchrony.py +++ b/elephant/test/test_spike_train_synchrony.py @@ -21,49 +21,37 @@ def test_spike_contrast_random(self): # randomly generated spiketrains that share the same t_start and # t_stop np.random.seed(24) # to make the results reproducible - spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_3 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_4 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_5 = stgen.homogeneous_poisson_process(rate=1 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_6 = stgen.homogeneous_poisson_process(rate=1 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) + poisson_process_1 = stgen.StationaryPoissonProcess( + rate=10.*Hz, t_start=0.*ms, t_stop=10000.*ms) + poisson_process_2 = stgen.StationaryPoissonProcess( + rate=1.*Hz, t_start=0.*ms, t_stop=10000.*ms) + spike_train_1 = poisson_process_1.generate_spiketrain() + spike_train_2 = poisson_process_1.generate_spiketrain() + spike_train_3 = poisson_process_1.generate_spiketrain() + spike_train_4 = poisson_process_1.generate_spiketrain() + spike_train_5 = poisson_process_2.generate_spiketrain() + spike_train_6 = poisson_process_2.generate_spiketrain() + spike_trains = [spike_train_1, spike_train_2, spike_train_3, spike_train_4, spike_train_5, spike_train_6] synchrony = spike_contrast(spike_trains) - self.assertAlmostEqual(synchrony, 0.2098687, places=6) + self.assertAlmostEqual(synchrony, 0.1875795, places=6) def test_spike_contrast_same_signal(self): np.random.seed(21) - spike_train = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) + spike_train = stgen.StationaryPoissonProcess( + rate=10.*Hz, t_start=0.*ms, t_stop=10000.*ms).generate_spiketrain() spike_trains = [spike_train, spike_train] synchrony = spike_contrast(spike_trains, min_bin=1 * ms) self.assertEqual(synchrony, 1.0) def test_spike_contrast_double_duration(self): np.random.seed(19) - spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_3 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) + poisson_process = stgen.StationaryPoissonProcess( + rate=10 * Hz, t_start=0. * ms, t_stop=10000. * ms) + spike_train_1 = poisson_process.generate_spiketrain() + spike_train_2 = poisson_process.generate_spiketrain() + spike_train_3 = poisson_process.generate_spiketrain() spike_trains = [spike_train_1, spike_train_2, spike_train_3] synchrony = spike_contrast(spike_trains, t_stop=20000 * ms) @@ -71,12 +59,12 @@ def test_spike_contrast_double_duration(self): def test_spike_contrast_non_overlapping_spiketrains(self): np.random.seed(15) - spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=0. * ms, - t_stop=10000. * ms) - spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_start=5000. * ms, - t_stop=10000. * ms) + spike_train_1 = stgen.StationaryPoissonProcess( + rate=10 * Hz, t_start=0. * ms, t_stop=10000. * ms + ).generate_spiketrain() + spike_train_2 = stgen.StationaryPoissonProcess( + rate=10 * Hz, t_start=5000. * ms, t_stop=10000. * ms + ).generate_spiketrain() spiketrains = [spike_train_1, spike_train_2] synchrony = spike_contrast(spiketrains, t_stop=5000 * ms) # the synchrony of non-overlapping spiketrains must be zero @@ -84,10 +72,10 @@ def test_spike_contrast_non_overlapping_spiketrains(self): def test_spike_contrast_trace(self): np.random.seed(15) - spike_train_1 = stgen.homogeneous_poisson_process(rate=20 * Hz, - t_stop=1000. * ms) - spike_train_2 = stgen.homogeneous_poisson_process(rate=20 * Hz, - t_stop=1000. * ms) + poisson_process = stgen.StationaryPoissonProcess( + rate=10 * Hz, t_start=0. * ms, t_stop=1000. * ms) + spike_train_1 = poisson_process.generate_spiketrain() + spike_train_2 = poisson_process.generate_spiketrain() synchrony, trace = spike_contrast([spike_train_1, spike_train_2], return_trace=True) self.assertEqual(synchrony, max(trace.synchrony)) @@ -127,10 +115,10 @@ def test_invalid_data(self): def test_t_start_agnostic(self): np.random.seed(15) t_stop = 10 * second - spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_stop=t_stop) - spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz, - t_stop=t_stop) + poisson_process = stgen.StationaryPoissonProcess( + rate=10 * Hz, t_stop=t_stop) + spike_train_1 = poisson_process.generate_spiketrain() + spike_train_2 = poisson_process.generate_spiketrain() spiketrains = [spike_train_1, spike_train_2] synchrony_target = spike_contrast(spiketrains) # a check for developer: test meaningful result diff --git a/elephant/test/test_unitary_event_analysis.py b/elephant/test/test_unitary_event_analysis.py index b1304fb98..02fee6bd4 100644 --- a/elephant/test/test_unitary_event_analysis.py +++ b/elephant/test/test_unitary_event_analysis.py @@ -16,7 +16,7 @@ import elephant.unitary_event_analysis as ue from elephant.test.download import download, ELEPHANT_TMP_DIR from numpy.testing import assert_array_almost_equal -from elephant.spike_train_generation import homogeneous_poisson_process +from elephant.spike_train_generation import StationaryPoissonProcess class UETestCase(unittest.TestCase): @@ -115,7 +115,7 @@ def test_hash_default(self): def test_hash_default_longpattern(self): m = np.zeros((100, 2)) m[0, 0] = 1 - expected = np.array([2**99, 0]) + expected = np.array([2 ** 99, 0]) h = ue.hash_from_pattern(m) self.assertTrue(np.all(expected == h)) @@ -168,7 +168,7 @@ def test_invhash_shape_mat(self): N = 8 h = np.array([178, 212, 232]) expected = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [ - 1, 1, 0], [1, 0, 1], [0, 1, 1], [1, 1, 1]]) + 1, 1, 0], [1, 0, 1], [0, 1, 1], [1, 1, 1]]) m = ue.inverse_hash_from_pattern(h, N) self.assertTrue(np.shape(m)[0] == N) @@ -301,13 +301,13 @@ def test__UE_default(self): def test__UE_surrogate(self): mat = self.binary_sts pattern_hash = np.array([4]) - _, rate_avg_surr, _, n_emp_surr, indices_surr =\ + _, rate_avg_surr, _, n_emp_surr, indices_surr = \ ue._UE( mat, pattern_hash, method='surrogate_TrialByTrial', n_surrogates=100) - _, rate_avg, _, n_emp, indices =\ + _, rate_avg, _, n_emp, indices = \ ue._UE(mat, pattern_hash, method='analytic_TrialByTrial') self.assertTrue(np.allclose(n_emp, n_emp_surr)) self.assertTrue(np.allclose(rate_avg, rate_avg_surr)) @@ -492,34 +492,51 @@ def test_Riehle_et_al_97_UE(self): def test_multiple_neurons(self): np.random.seed(12) - spiketrains = [[homogeneous_poisson_process( - rate=50 * pq.Hz, t_stop=1 * pq.s) - for _ in range(5)] for neuron in range(3)] + spiketrains = \ + [StationaryPoissonProcess( + rate=50 * pq.Hz, t_stop=1 * pq.s).generate_n_spiketrains(5) + for neuron in range(3)] spiketrains = np.stack(spiketrains, axis=1) UE_dic = ue.jointJ_window_analysis(spiketrains, bin_size=5 * pq.ms, win_size=300 * pq.ms, win_step=100 * pq.ms) - js_expected = [[0.6081138], [0.17796665], [-1.2601125], - [-0.2790147], [0.07804556], [0.7861176], [0.23452221], - [0.11624397]] - indices_expected = {'trial2': [20, 30, 20, 30, 104, 104, 104], - 'trial3': [21, 21, 65, 65, 65, 128, 128, 128], - 'trial4': [8, 172, 172], - 'trial0': [104, 106, 104, 106, 104, 106], - 'trial1': [158, 158, 158, 188]} - n_emp_expected = [[4.], [4.], [1.], [4.], [4.], [5.], [3.], [3.]] - n_exp_expected = [[2.2858334], [3.2066667], [2.955], [4.485833], - [3.4622223], [2.723611], [2.166111], [2.4122221]] - rate_expected = [[[0.04666667, 0.03266666, 0.04333333]], - [[0.04733333, 0.03666667, 0.044]], - [[0.04533333, 0.03466666, 0.046]], - [[0.04933333, 0.04466667, 0.04933333]], - [[0.04466667, 0.04266667, 0.046]], - [[0.04133333, 0.04466667, 0.044]], - [[0.04133333, 0.03666667, 0.04266667]], - [[0.03933334, 0.03866667, 0.04666667]]] * 1 / pq.ms + js_expected = [[0.3978179], + [0.08131966], + [-1.4239882], + [-0.9377029], + [-0.3374434], + [-0.2043383], + [-1.001536], + [-np.inf]] + indices_expected = \ + {'trial3': [12, 27, 31, 34, 27, 31, 34, 136, 136, 136], + 'trial4': [4, 60, 60, 60, 117, 117, 117]} + n_emp_expected = [[5.], + [4.], + [1.], + [2.], + [2.], + [2.], + [1.], + [0.]] + n_exp_expected = [[3.5591667], + [3.4536111], + [3.3158333], + [3.8466666], + [2.370278], + [2.0811112], + [2.4011111], + [3.0533333]] + rate_expected = [[[0.042, 0.03933334, 0.048]], + [[0.04533333, 0.038, 0.05]], + [[0.046, 0.04, 0.04666667]], + [[0.05066667, 0.042, 0.046]], + [[0.04466667, 0.03666667, 0.04066667]], + [[0.04066667, 0.03533333, 0.04333333]], + [[0.03933334, 0.038, 0.038]], + [[0.04066667, 0.04866667, 0.03666667]]] * (1. / pq.ms) input_parameters_expected = {'pattern_hash': [7], 'bin_size': 5 * pq.ms, 'win_size': 300 * pq.ms, @@ -527,6 +544,7 @@ def test_multiple_neurons(self): 'method': 'analytic_TrialByTrial', 't_start': 0 * pq.s, 't_stop': 1 * pq.s, 'n_surrogates': 100} + assert_array_almost_equal(UE_dic['Js'], js_expected) assert_array_almost_equal(UE_dic['n_emp'], n_emp_expected) assert_array_almost_equal(UE_dic['n_exp'], n_exp_expected) From 8fd05f66f640e785a086fdcdb34bf9e254d1a358 Mon Sep 17 00:00:00 2001 From: Maximilian Kramer <56024817+ojoenlanuca@users.noreply.github.com> Date: Tue, 23 Nov 2021 09:36:07 +0100 Subject: [PATCH 28/63] BUG-Fix #424: t_start information was lost while transposing lfp (#432) This is a fix related to issue #424: t_start was lost while transposing lfp, because t_start was not set in the redefinition of the new neo.analogSignal. Fixed by transposing the neo.Analogsignal directly. @ojoenlanuca , @rgutzen --- elephant/current_source_density.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/elephant/current_source_density.py b/elephant/current_source_density.py index edf5b2cee..686c1fde9 100644 --- a/elephant/current_source_density.py +++ b/elephant/current_source_density.py @@ -185,10 +185,8 @@ def estimate_csd(lfp, coordinates=None, method=None, raise ValueError("The order of {} filter must be \ specified".format(kwargs['f_type'])) - lfp = neo.AnalogSignal(np.asarray(lfp).T, units=lfp.units, - sampling_rate=lfp.sampling_rate) csd_method = getattr(icsd, method) # fetch class from icsd.py file - csd_estimator = csd_method(lfp=lfp.magnitude * lfp.units, + csd_estimator = csd_method(lfp=lfp.T.magnitude * lfp.units, coord_electrode=coordinates.flatten(), **kwargs) csd_pqarr = csd_estimator.get_csd() From b53be3e3f486ecb100b5f5b1d0d63b391b4fdac5 Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Tue, 7 Dec 2021 14:05:27 +0100 Subject: [PATCH 29/63] Fixed test suite building for multiple modules (#426) * Replaced custom test build with unittest.main() in - test_cell_assembly_detection.py - test_cubic.py - test_gpfa.py - test_icsd.py - test_spade.py - test_spike_train_surrogates.py * Fixed deprecation warnings in test_cell_assembly_detection.py: - numpy.testing.utils -> numpy.testing - data -> binned_spiketrain - maxlag -> max_lag - min_occ -> min_occurrences * Fixed deprecation warning (ximax -> max_iteractions) in test_cubic.py * Fixed typo in test_cubic.py * removed redundant blank lines at the end of code blocks --- elephant/spade_src/include/FPNode.h | 15 ++++--- elephant/spade_src/include/Utils.h | 23 +++++----- elephant/test/test_cell_assembly_detection.py | 42 ++++++++----------- elephant/test/test_cubic.py | 28 ++++++------- elephant/test/test_gpfa.py | 12 +----- elephant/test/test_icsd.py | 28 +------------ elephant/test/test_spade.py | 7 +--- elephant/test/test_spike_train_surrogates.py | 8 +--- 8 files changed, 52 insertions(+), 111 deletions(-) diff --git a/elephant/spade_src/include/FPNode.h b/elephant/spade_src/include/FPNode.h index 53465cffb..221cdab24 100644 --- a/elephant/spade_src/include/FPNode.h +++ b/elephant/spade_src/include/FPNode.h @@ -1,19 +1,19 @@ -/* +/* * File: FPNode.h * Copyright (c) 2020 Florian Porrmann - * + * * MIT License - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE @@ -21,7 +21,7 @@ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. - * + * */ #pragma once @@ -96,5 +96,4 @@ struct FPNode os << "id=" << rhs.id << "; support=" << rhs.support << "; parent=" << rhs.parent << "; succ=" << rhs.succ; return os; } - -}; +}; \ No newline at end of file diff --git a/elephant/spade_src/include/Utils.h b/elephant/spade_src/include/Utils.h index 3bc812fac..af5f27a0b 100644 --- a/elephant/spade_src/include/Utils.h +++ b/elephant/spade_src/include/Utils.h @@ -1,19 +1,19 @@ -/* +/* * File: Utils.h * Copyright (c) 2020 Florian Porrmann - * + * * MIT License - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE @@ -21,7 +21,7 @@ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. - * + * */ #pragma once @@ -240,7 +240,7 @@ void quicksort(std::vector>& values, const uint32_t& left, const // // Fill the zipped vector with pairs consisting of the -// corresponding elements of a and b. (This assumes +// corresponding elements of a and b. (This assumes // that the vectors have equal length) template void zip(const std::vector& a, const std::vector& b, std::vector>& zipped) @@ -248,8 +248,8 @@ void zip(const std::vector& a, const std::vector& b, std::vector void unzip(const std::vector>& zipped, std::vector& a, std::vector& b) @@ -270,7 +270,6 @@ void zipSort(std::vector& data, std::vector& sortBy) // quicksort(zipped, 0, zipped.size() - 1); unzip(zipped, data, sortBy); - } // @@ -364,7 +363,7 @@ static inline std::string SizeWithSuffix(const int64_t& val) #include #endif -#ifdef __linux__ +#ifdef __linux__ #include #endif @@ -398,4 +397,4 @@ uint64_t GetCurrentRSS() std::string GetMemString() { return SizeWithSuffix(GetCurrentRSS()); -} +} \ No newline at end of file diff --git a/elephant/test/test_cell_assembly_detection.py b/elephant/test/test_cell_assembly_detection.py index 64d7ad771..152eae7d6 100644 --- a/elephant/test/test_cell_assembly_detection.py +++ b/elephant/test/test_cell_assembly_detection.py @@ -5,7 +5,7 @@ import unittest import numpy as np -from numpy.testing.utils import assert_array_equal +from numpy.testing import assert_array_equal import neo import quantities as pq import elephant.conversion as conv @@ -22,7 +22,7 @@ def setUp(self): self.size_chunks = 100 self.max_lag = 10 self.reference_lag = 2 - self.min_occ = 1 + self.min_occurrences = 1 self.max_spikes = np.inf self.significance_pruning = True self.subgroup_pruning = True @@ -132,73 +132,67 @@ def test_cad_msip(self): def test_cad_raise_error(self): # test error data input format self.assertRaises(TypeError, cad.cell_assembly_detection, - data=[[1, 2, 3], [3, 4, 5]], - maxlag=self.max_lag) + binned_spiketrain=[[1, 2, 3], [3, 4, 5]], + max_lag=self.max_lag) # test error significance level self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], bin_size=self.bin_size), - maxlag=self.max_lag, + max_lag=self.max_lag, alpha=-3) # test error minimum number of occurrences self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], bin_size=self.bin_size), - maxlag=self.max_lag, - min_occ=-1) + max_lag=self.max_lag, + min_occurrences=-1) # test error minimum number of spikes in a pattern self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], bin_size=self.bin_size), - maxlag=self.max_lag, + max_lag=self.max_lag, max_spikes=1) # test error chunk size for variance computation self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], bin_size=self.bin_size), - maxlag=self.max_lag, + max_lag=self.max_lag, size_chunks=1) # test error maximum lag self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], bin_size=self.bin_size), - maxlag=1) + max_lag=1) # test error minimum length spike train self.assertRaises(ValueError, cad.cell_assembly_detection, - data=conv.BinnedSpikeTrain( + binned_spiketrain=conv.BinnedSpikeTrain( [neo.SpikeTrain([1, 2, 3] * pq.ms, t_stop=6 * pq.ms), neo.SpikeTrain([3, 4, 5] * pq.ms, t_stop=6 * pq.ms)], bin_size=1 * pq.ms), - maxlag=self.max_lag) - - -def suite(): - suite = unittest.makeSuite(CadTestCase, 'test') - return suite + max_lag=self.max_lag) if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) diff --git a/elephant/test/test_cubic.py b/elephant/test/test_cubic.py index 31938a265..ee077ad5e 100644 --- a/elephant/test/test_cubic.py +++ b/elephant/test/test_cubic.py @@ -36,7 +36,7 @@ def setUp(self): pq.dimensionless, sampling_period=1 * pq.s) self.data_array = numpy.array([self.xi] * n2 + [0] * n0) self.alpha = 0.05 - self.ximax = 10 + self.max_iterations = 10 def test_cubic(self): @@ -103,14 +103,15 @@ def test_cubic(self): # Check the output for test_aborted self.assertEqual(test_aborted, False) - def test_cubic_ximax(self): - # Test exceeding ximax + def test_cubic_max_iterations(self): + # Test exceeding max_iterations with self.assertWarns(UserWarning): - xi_ximax, p_vals_ximax, k_ximax, test_aborted = cubic.cubic( - self.data_signal, alpha=1, max_iterations=self.ximax) + xi_max_iterations, p_vals_max_iterations, k_max_iterations, \ + test_aborted = cubic.cubic(self.data_signal, alpha=1, + max_iterations=self.max_iterations) self.assertEqual(test_aborted, True) - self.assertEqual(xi_ximax - 1, self.ximax) + self.assertEqual(xi_max_iterations - 1, self.max_iterations) def test_cubic_errors(self): @@ -131,21 +132,16 @@ def test_cubic_errors(self): # Negative alpha self.assertRaises(ValueError, cubic.cubic, self.data_array, alpha=-0.1) - # Negative number of iterations ximax - self.assertRaises(ValueError, cubic.cubic, self.data_array, ximax=-100) + # Negative number of max_iterations + self.assertRaises(ValueError, cubic.cubic, self.data_array, + max_iterations=-100) # Checking case in which the second cumulant of the signal is smaller - # than the first cumulant (analitycal constrain of the method) + # than the first cumulant (analytical constrain of the method) self.assertRaises(ValueError, cubic.cubic, neo.AnalogSignal( numpy.array([1] * 1000).reshape(1000, 1), units=pq.dimensionless, sampling_period=10 * pq.ms), alpha=self.alpha) -def suite(): - suite = unittest.makeSuite(CubicTestCase, 'test') - return suite - - if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) diff --git a/elephant/test/test_gpfa.py b/elephant/test/test_gpfa.py index a571ed3d8..e6969367b 100644 --- a/elephant/test/test_gpfa.py +++ b/elephant/test/test_gpfa.py @@ -216,15 +216,5 @@ def test_logdet(self): assert_array_almost_equal(logdet_fast, logdet_ground_truth) -def suite(): - suite = unittest.makeSuite(GPFATestCase, 'test') - return suite - - -def run(): - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) - - if __name__ == "__main__": - unittest.main() + unittest.main(verbosity=2) diff --git a/elephant/test/test_icsd.py b/elephant/test/test_icsd.py index 4553b109a..2b4bb844c 100644 --- a/elephant/test/test_icsd.py +++ b/elephant/test/test_icsd.py @@ -1202,31 +1202,5 @@ def test_SplineiCSD_04(self): nt.assert_array_almost_equal(C_i, csd, decimal=3) -# def suite(verbosity=2): -# """ -# Run unittests for the CSD toolbox -# -# -# Arguments -# --------- -# verbosity : int -# verbosity level -# -# """ -# suite = unittest.TestLoader().loadTestsFromTestCase(TestICSD) -# unittest.TextTestRunner(verbosity=verbosity).run(suite) -# -# -# -# if __name__ == '__main__': -# suite() - - -def suite(): - suite = unittest.makeSuite(TestICSD, 'test') - return suite - - if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index c4c498269..299bc62b7 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -701,11 +701,6 @@ def test_signature_significance_fdr_bh_corr(self): alpha=0.15, winlen=1, corr='fdr_bh') self.assertEqual(sig_spectrum, [(2., 3., False), (2., 4., True)]) -def suite(): - suite = unittest.makeSuite(SpadeTestCase, 'test') - return suite - if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) diff --git a/elephant/test/test_spike_train_surrogates.py b/elephant/test/test_spike_train_surrogates.py index cca6174cb..454208193 100644 --- a/elephant/test/test_spike_train_surrogates.py +++ b/elephant/test/test_spike_train_surrogates.py @@ -697,11 +697,5 @@ def test_trial_shuffling_empty_train_concatenated(self): self.assertEqual(len(surrogate_train), 0) -def suite(): - suite = unittest.makeSuite(SurrogatesTestCase, 'test') - return suite - - if __name__ == "__main__": - runner = unittest.TextTestRunner(verbosity=2) - runner.run(suite()) + unittest.main(verbosity=2) From 0c54079a973379ee88079748e482f7f3ef2ee4ba Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Tue, 7 Dec 2021 16:08:07 +0100 Subject: [PATCH 30/63] Fix for figures in the Granger causality tutorial (#434) The plots generated in the Granger causality tutorial had incorrect axis ranges. This was fixed by setting x- and y-axis bounds in both plots. - Fixed the figures in granger_causality.ipynb tutorial --- doc/tutorials/granger_causality.ipynb | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/doc/tutorials/granger_causality.ipynb b/doc/tutorials/granger_causality.ipynb index c677d657c..45e27e6bd 100644 --- a/doc/tutorials/granger_causality.ipynb +++ b/doc/tutorials/granger_causality.ipynb @@ -51,6 +51,8 @@ "ax1.text(0.5, 0.6, 'Z', horizontalalignment='center', verticalalignment='center')\n", "ax1.text(0.8, 0.2, 'X', horizontalalignment='center', verticalalignment='center')\n", "ax1.set_title('Indirect only')\n", + "ax1.set_xbound((0, 1))\n", + "ax1.set_ybound((0, 0.8))\n", "\n", "ax1.tick_params(axis='both', which='both', bottom=False, top=False, labelbottom=False, \n", " right=False, left=False, labelleft=False)\n", @@ -69,11 +71,13 @@ "ax2.text(0.2, 0.2, 'Y', horizontalalignment='center', verticalalignment='center')\n", "ax2.text(0.5, 0.6, 'Z', horizontalalignment='center', verticalalignment='center')\n", "ax2.text(0.8, 0.2, 'X', horizontalalignment='center', verticalalignment='center')\n", + "ax2.set_xbound((0, 1))\n", + "ax2.set_ybound((0, 0.8))\n", "\n", "ax2.tick_params(axis='both', which='both', bottom=False, top=False, labelbottom=False, \n", " right=False, left=False, labelleft=False)\n", "ax2.set_title('Both direct and indirect')\n", - "\n", + "plt.tight_layout()\n", "plt.show()" ] }, @@ -223,7 +227,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.7.3" } }, "nbformat": 4, From cfdecd86d221235ebdf87c249315faaa2fbf4c2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristiano=20K=C3=B6hler?= <42555442+kohlerca@users.noreply.github.com> Date: Fri, 17 Dec 2021 11:09:56 +0100 Subject: [PATCH 31/63] Updated zscore for in-place operations (#440) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Updated zscore to change the units to dimensionless when performing in-place operations, and also to return the original object instead of a new AnalogSignal object pointing to the original array. * Changed to raise ValueError when the in-place operation is not valid. * New AnalogSignal object is created using Neo function. * Updated unit tests to check for same/different objects when doing in-place operation in zscore. * Changed test_zscore_single_inplace_int as the function now raises ValueError. Co-authored-by: Cristiano Köhler --- elephant/signal_processing.py | 51 ++++++++++++++++--------- elephant/test/test_signal_processing.py | 45 +++++++++++++++------- 2 files changed, 66 insertions(+), 30 deletions(-) diff --git a/elephant/signal_processing.py b/elephant/signal_processing.py index e512bfd70..bab1aad00 100644 --- a/elephant/signal_processing.py +++ b/elephant/signal_processing.py @@ -27,6 +27,8 @@ from elephant.utils import deprecated_alias, check_same_units +import warnings + __all__ = [ "zscore", "cross_correlation_function", @@ -66,16 +68,22 @@ def zscore(signal, inplace=True): inplace : bool, optional If True, the contents of the input `signal` is replaced by the z-transformed signal, if possible, i.e when the signal type is float. + If the signal type is not float, an error is raised. If False, a copy of the original `signal` is returned. Default: True Returns ------- - signal_ztransofrmed : neo.AnalogSignal or list of neo.AnalogSignal + signal_ztransformed : neo.AnalogSignal or list of neo.AnalogSignal The output format matches the input format: for each input `neo.AnalogSignal`, a corresponding `neo.AnalogSignal` is returned, containing the z-transformed signal with dimensionless unit. + Raises + ------ + ValueError + If `inplace` is True and the type of `signal` is not float. + Notes ----- You may supply a list of `neo.AnalogSignal` objects, where each object in @@ -153,29 +161,38 @@ def zscore(signal, inplace=True): mean = signal_stacked.mean(axis=0) std = signal_stacked.std(axis=0) - signal_ztransofrmed = [] + signal_ztransformed = [] for sig in signal: + # Perform inplace operation only if array is of dtype float. + # Otherwise, raise an error. + if inplace and not np.issubdtype(np.float, sig.dtype): + raise ValueError(f"Cannot perform inplace operation as the " + f"signal dtype is not float. Source: {sig.name}") + sig_normalized = sig.magnitude.astype(mean.dtype, copy=not inplace) sig_normalized -= mean + # items where std is zero are already zero np.divide(sig_normalized, std, out=sig_normalized, where=std != 0) - sig_dimless = neo.AnalogSignal(signal=sig_normalized, - units=pq.dimensionless, - dtype=sig_normalized.dtype, - copy=False, - t_start=sig.t_start, - sampling_rate=sig.sampling_rate, - name=sig.name, - file_origin=sig.file_origin, - description=sig.description, - array_annotations=sig.array_annotations, - **sig.annotations) - signal_ztransofrmed.append(sig_dimless) + + if inplace: + # Replace unit in the original array by dimensionless + sig._dimensionality = pq.dimensionless.dimensionality + sig_dimless = sig + else: + # Create new object + sig_dimless = sig.duplicate_with_new_data(sig_normalized, + units=pq.dimensionless) + # todo use flag once is fixed + # https://github.com/NeuralEnsemble/python-neo/issues/752 + sig_dimless.array_annotate(**sig.array_annotations) + + signal_ztransformed.append(sig_dimless) # Return single object, or list of objects - if len(signal_ztransofrmed) == 1: - signal_ztransofrmed = signal_ztransofrmed[0] - return signal_ztransofrmed + if len(signal_ztransformed) == 1: + signal_ztransformed = signal_ztransformed[0] + return signal_ztransformed @deprecated_alias(ch_pairs='channel_pairs', nlags='n_lags', diff --git a/elephant/test/test_signal_processing.py b/elephant/test/test_signal_processing.py index 3596c375e..a139f9bb2 100644 --- a/elephant/test/test_signal_processing.py +++ b/elephant/test/test_signal_processing.py @@ -195,6 +195,9 @@ def test_zscore_single_dup(self): # Assert original signal is untouched self.assertEqual(signal[0].magnitude, self.test_seq1[0]) + # Assert original and returned objects are different + self.assertIsNot(result, signal) + def test_zscore_single_inplace(self): """ Test z-score on a single AnalogSignal, asking for an inplace @@ -218,6 +221,9 @@ def test_zscore_single_inplace(self): # Assert original signal is overwritten self.assertEqual(signal[0].magnitude, target[0]) + # Assert original and returned objects are the same + self.assertIs(result, signal) + def test_zscore_single_multidim_dup(self): """ Test z-score on a single AnalogSignal with multiple dimensions, asking @@ -232,13 +238,15 @@ def test_zscore_single_multidim_dup(self): s = np.std(signal.magnitude, axis=0, keepdims=True) target = (signal.magnitude - m) / s - assert_array_almost_equal( - elephant.signal_processing.zscore( - signal, inplace=False).magnitude, target, decimal=9) + result = elephant.signal_processing.zscore(signal, inplace=False) + assert_array_almost_equal(result.magnitude, target, decimal=9) # Assert original signal is untouched self.assertEqual(signal[0, 0].magnitude, self.test_seq1[0]) + # Assert original and returned objects are different + self.assertIsNot(result, signal) + def test_zscore_array_annotations(self): signal = neo.AnalogSignal( self.test_seq1, units='mV', @@ -269,6 +277,9 @@ def test_zscore_single_multidim_inplace(self): # Assert original signal is overwritten self.assertAlmostEqual(signal[0, 0].magnitude, ground_truth[0, 0]) + # Assert original and returned objects are the same + self.assertIs(result, signal) + def test_zscore_single_dup_int(self): """ Test if the z-score is correctly calculated even if the input is an @@ -283,28 +294,28 @@ def test_zscore_single_dup_int(self): s = np.std(self.test_seq1) target = (self.test_seq1 - m) / s - assert_array_almost_equal( - elephant.signal_processing.zscore(signal, inplace=False).magnitude, - target.reshape(-1, 1), decimal=9) + result = elephant.signal_processing.zscore(signal, inplace=False) + assert_array_almost_equal(result.magnitude, target.reshape(-1, 1), + decimal=9) # Assert original signal is untouched self.assertEqual(signal.magnitude[0], self.test_seq1[0]) + # Assert original and returned objects are different + self.assertIsNot(result, signal) + def test_zscore_single_inplace_int(self): """ - Test if the z-score is correctly calculated even if the input is an - AnalogSignal of type int, asking for an inplace operation. + Test if the z-score operation fails if the input is an + AnalogSignal of type int, when asking for an inplace operation. """ - m = np.mean(self.test_seq1) - s = np.std(self.test_seq1) - target = (self.test_seq1 - m) / s signal = neo.AnalogSignal( self.test_seq1, units='mV', t_start=0. * pq.ms, sampling_rate=1000. * pq.Hz, dtype=int) - zscored = elephant.signal_processing.zscore(signal, inplace=True) - assert_array_almost_equal(zscored.magnitude.squeeze(), target) + with self.assertRaises(ValueError): + elephant.signal_processing.zscore(signal, inplace=True) def test_zscore_list_dup(self): """ @@ -344,6 +355,10 @@ def test_zscore_list_dup(self): self.assertEqual(signal1.magnitude[0, 0], self.test_seq1[0]) self.assertEqual(signal2.magnitude[0, 1], self.test_seq2[0]) + # Assert original and returned objects are different + self.assertIsNot(result[0], signal_list[0]) + self.assertIsNot(result[1], signal_list[1]) + def test_zscore_list_inplace(self): """ Test zscore on a list of AnalogSignal objects, asking for an @@ -382,6 +397,10 @@ def test_zscore_list_inplace(self): self.assertEqual(signal1[0, 0].magnitude, target11[0]) self.assertEqual(signal2[0, 0].magnitude, target21[0]) + # Assert original and returned objects are the same + self.assertIs(result[0], signal_list[0]) + self.assertIs(result[1], signal_list[1]) + def test_wrong_input(self): # wrong type self.assertRaises(TypeError, elephant.signal_processing.zscore, From 784fb8d2acbfc7cf6d27eb324cbfd63c58d2861b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paulina=20D=C4=85browska?= <22954452+PaulinaDabrowska@users.noreply.github.com> Date: Mon, 10 Jan 2022 09:16:32 +0100 Subject: [PATCH 32/63] Added missing rescaling of t_start and t_stop to the units of spiketrain (#425) --- elephant/conversion.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index 4f5dc5672..0c9615258 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -541,8 +541,10 @@ def check_consistency(): self._t_start = self._t_start.rescale(self.units).item() self._t_stop = self._t_stop.rescale(self.units).item() - start_shared = max(st.t_start.item() for st in spiketrains) - stop_shared = min(st.t_stop.item() for st in spiketrains) + start_shared = max(st.t_start.rescale(self.units).item() + for st in spiketrains) + stop_shared = min(st.t_stop.rescale(self.units).item() + for st in spiketrains) tolerance = self.tolerance if tolerance is None: From db250349975f9ad80bbe9ce5e290a1a47698eebf Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 9 Feb 2022 11:25:29 +0100 Subject: [PATCH 33/63] Updated spade tutorial to work with viziphant 0.2.0 (#88) (#444) --- doc/tutorials/spade.ipynb | 20 +++----------------- 1 file changed, 3 insertions(+), 17 deletions(-) diff --git a/doc/tutorials/spade.ipynb b/doc/tutorials/spade.ipynb index 892cb361c..951220031 100644 --- a/doc/tutorials/spade.ipynb +++ b/doc/tutorials/spade.ipynb @@ -146,27 +146,13 @@ }, "outputs": [], "source": [ - "viziphant.spade.plot_patterns(spiketrains, patterns)" + "viziphant.patterns.plot_patterns(spiketrains, patterns)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -180,7 +166,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.10" }, "latex_envs": { "LaTeX_envs_menu_present": true, From a5cd9c6218a56614fe3c196ed56cb531b753bb8d Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 9 Feb 2022 12:05:45 +0100 Subject: [PATCH 34/63] Add zenodo badge to README.md (#445) * Update README.md added zenodo batch with DOI * Update README.md Co-authored-by: Michael Denker Co-authored-by: Michael Denker --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 6c9a0aa69..0f4d28432 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ [![![PyPi]](https://img.shields.io/pypi/v/elephant)](https://pypi.org/project/elephant/) [![Statistics](https://img.shields.io/pypi/dm/elephant)](https://seladb.github.io/StarTrack-js/#/preload?r=neuralensemble,elephant) [![Gitter](https://badges.gitter.im/python-elephant/community.svg)](https://gitter.im/python-elephant/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) +[![DOI Latest Release](https://zenodo.org/badge/10311278.svg)](https://zenodo.org/badge/latestdoi/10311278) + *Elephant* package analyses all sorts of neurophysiological data: spike trains, LFP, analog signals. The input-output data format is either From 9caa5bf73eb23d04f147b52c3be72dc8310b6860 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 9 Feb 2022 17:34:41 +0100 Subject: [PATCH 35/63] Fix pytest (#449) * fix for bug related to pytest 7.0.0, fixed version to 6.2.5 thus fixing errors when running pytest with `--import-mode=importlib` * Update .travis.yml Co-authored-by: Michael Denker --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index 2fcd4c1da..43be16787 100644 --- a/.travis.yml +++ b/.travis.yml @@ -64,6 +64,7 @@ install: - pip -V - pip install -r requirements/requirements-tests.txt + - pip install pytest==6.2.5 # hotfix as pytest 7.0.0 breaks CI workflows with --import-mode=importlib - pip install pytest-cov coveralls - pip install . - python -c "import sys; sys.path.remove(''); import elephant; print(elephant.__file__, elephant.__version__)" @@ -73,3 +74,4 @@ install: script: pytest --cov=elephant --import-mode=importlib + \ No newline at end of file From d0d39206a5a2bff0d57d365a63a30e402dbc597d Mon Sep 17 00:00:00 2001 From: Regimantas Jurkus Date: Thu, 10 Feb 2022 13:02:14 +0100 Subject: [PATCH 36/63] Feature/multitaper psd estimate (#417) New Feature: multitaper psd estimate. Tests include a comparison against nitime multitaper. --- elephant/spectral.py | 246 +++++++++++++++++++++++++++++++++ elephant/test/test_spectral.py | 148 ++++++++++++++++++++ 2 files changed, 394 insertions(+) diff --git a/elephant/spectral.py b/elephant/spectral.py index cd41ea471..661cac76e 100644 --- a/elephant/spectral.py +++ b/elephant/spectral.py @@ -270,6 +270,252 @@ def welch_psd(signal, n_segments=8, len_segment=None, return freqs, psd +def multitaper_psd(signal, n_segments=1, len_segment=None, + frequency_resolution=None, overlap=0.5, fs=1, + nw=4, num_tapers=None, peak_resolution=None, axis=-1): + """ + Estimates power spectrum density (PSD) of a given 'neo.AnalogSignal' + using Multitaper method + + The PSD is obtained through the following steps: + + 1. Cut the given data into several overlapping segments. The degree of + overlap can be specified by parameter `overlap` (default is 0.5, + i.e. segments are overlapped by the half of their length). + The number and the length of the segments are determined according + to the parameters `n_segments`, `len_segment` or `frequency_resolution`. + By default, the data is cut into 8 segments; + + 2. Calculate 'num_tapers' approximately independent estimates of the + spectrum by multiplying the signal with the discrete prolate spheroidal + functions (also known as Slepian function) and calculate the PSD of each + tapered segment + + 3. Average the approximately independent estimates of each segment to + decrease overall variance of the estimates + + 4. Average the obtained estimates for each segment + + Parameters + ---------- + signal : neo.AnalogSignal + Time series data of which PSD is estimated. When `signal` is np.ndarray + sampling frequency should be given through keyword argument `fs`. + Signal should be passed as (n_channels, n_samples) + fs : float, optional + Specifies the sampling frequency of the input time series + Default: 1.0. + n_segments : int, optional + Number of segments. The length of segments is adjusted so that + overlapping segments cover the entire stretch of the given data. This + parameter is ignored if `len_segment` or `frequency_resolution` is + given. + Default: 8. + len_segment : int, optional + Length of segments. This parameter is ignored if `frequency_resolution` + is given. If None, it will be determined from other parameters. + Default: None. + frequency_resolution : pq.Quantity or float, optional + Desired frequency resolution of the obtained PSD estimate in terms of + the interval between adjacent frequency bins. When given as a `float`, + it is taken as frequency in Hz. + If None, it will be determined from other parameters. + Default: None. + overlap : float, optional + Overlap between segments represented as a float number between 0 (no + overlap) and 1 (complete overlap). + Default: 0.5 (half-overlapped). + nw : float, optional + Time bandwidth product + Default: 4.0. + num_tapers : int, optional + Number of tapers used in 1. to obtain estimate of PSD. By default + [2*nw] - 1 is chosen. + Default: None. + peak_resolution : pq.Quantity float, optional + Quantity in Hz determining the number of tapers used for analysis. + Fine peak resolution --> low numerical value --> low number of tapers + High peak resolution --> high numerical value --> high number of tapers + When given as a `float`, it is taken as frequency in Hz. + Default: None. + axis : int, optional + Axis along which the periodogram is computed. + See Notes [2]. + Default: last axis (-1). + + Notes + ----- + 1. There is a parameter hierarchy regarding n_segments and len_segment. The + former parameter is ignored if the latter one is passed. + + 2. There is a parameter hierarchy regarding nw, num_tapers and + peak_resolution. If peak_resolution is provided, it determines both nw + and the num_tapers. Specifying num_tapers has an effect only if + peak_resolution is not provided. + + Returns + ------- + freqs : np.ndarray + Frequencies associated with power estimate in `psd` + psd : np.ndarray + PSD estimate of the time series in `signal` + + Raises + ------ + ValueError + If `peak_resolution` is None and `num_tapers` is not a positive number. + + If `frequency_resolution` is too high for the given data size. + + If `frequency_resolution` is None and `len_segment` is not a positive + number. + + If `frequency_resolution` is None and `len_segment` is greater than the + length of data at `axis`. + + If both `frequency_resolution` and `len_segment` are None and + `n_segments` is not a positive number. + + If both `frequency_resolution` and `len_segment` are None and + `n_segments` is greater than the length of data at `axis`. + + TypeError + If `peak_resolution` is None and `num_tapers` is not an int. + """ + + # When the input is AnalogSignal, the data is added after rolling the axis + # for time index to the last + data = np.asarray(signal) + if isinstance(signal, neo.AnalogSignal): + data = np.rollaxis(data, 0, len(data.shape)) + + # Number of data points in time series + if data.ndim == 1: + length_signal = np.shape(data)[0] + else: + length_signal = np.shape(data)[1] + + # If the data is given as AnalogSignal, use its attribute to specify the + # sampling frequency + if hasattr(signal, 'sampling_rate'): + fs = signal.sampling_rate.rescale('Hz').magnitude + + # If fs and peak resolution is pq.Quantity, get magnitude + if isinstance(fs, pq.quantity.Quantity): + fs = fs.rescale('Hz').magnitude + + # Determine length per segment - n_per_seg + if frequency_resolution is not None: + if frequency_resolution <= 0: + raise ValueError("frequency_resolution must be positive") + if isinstance(frequency_resolution, pq.quantity.Quantity): + dF = frequency_resolution.rescale('Hz').magnitude + else: + dF = frequency_resolution + n_per_seg = int(fs / dF) + if n_per_seg > data.shape[axis]: + raise ValueError("frequency_resolution is too high for the given " + "data size") + elif len_segment is not None: + if len_segment <= 0: + raise ValueError("len_seg must be a positive number") + elif data.shape[axis] < len_segment: + raise ValueError("len_seg must be shorter than the data length") + n_per_seg = len_segment + else: + if n_segments <= 0: + raise ValueError("n_segments must be a positive number") + elif data.shape[axis] < n_segments: + raise ValueError("n_segments must be smaller than the data length") + # when only *n_segments* is given, *n_per_seg* is determined by solving + # the following equation: + # n_segments * n_per_seg - (n_segments-1) * overlap * n_per_seg = + # data.shape[-1] + # -------------------- =============================== ^^^^^^^^^^^ + # summed segment lengths total overlap data length + n_per_seg = int(data.shape[axis] / + (n_segments - overlap * (n_segments - 1))) + + n_overlap = int(n_per_seg * overlap) + n_segments = int((length_signal - n_overlap) / (n_per_seg - n_overlap)) + + if isinstance(peak_resolution, pq.quantity.Quantity): + peak_resolution = peak_resolution.rescale('Hz').magnitude + + # Determine time-halfbandwidth product from given parameters + if peak_resolution is not None: + if peak_resolution <= 0: + raise ValueError("peak_resolution must be positive") + nw = n_per_seg / fs * peak_resolution / 2 + num_tapers = int(np.floor(2*nw) - 1) + + if num_tapers is None: + num_tapers = int(np.floor(2*nw) - 1) + else: + if not isinstance(num_tapers, int): + raise TypeError("num_tapers must be integer") + if num_tapers <= 0: + raise ValueError("num_tapers must be positive") + + # Generate frequencies of PSD estimate + freqs = np.fft.rfftfreq(n_per_seg, d=1/fs) + + # Zero-pad signal to fit segment length + remainder = length_signal % n_per_seg + + if data.ndim == 1: + data = np.pad(data, pad_width=(0, remainder), + mode='constant', constant_values=0) + # Generate array for storing PSD estimates of segments + psd_estimates = np.zeros((n_segments, len(freqs))) + else: + data = np.pad(data, [(0, 0), (0, remainder)], + mode='constant', constant_values=0) + # Generate array for storing PSD estimates of segments + psd_estimates = np.zeros((n_segments, data.shape[0], len(freqs))) + + # Determine the number of samples given overlap + n_overlap_step = n_per_seg - n_overlap + + for i in range(n_segments): + # Get slepian functions (sym=False used for spectral analysis) + slepian_fcts = scipy.signal.windows.dpss(M=n_per_seg, + NW=nw, + Kmax=num_tapers, + sym=False) + + # Calculate approximately independent spectrum estimates + if data.ndim == 1: + tapered_signal = (data[i * n_overlap_step: + i * n_overlap_step + n_per_seg] + * slepian_fcts) + else: + # Use broadcasting to match dim for point-wise multiplication + tapered_signal = (data[:, + np.newaxis, + i * n_overlap_step: + i * n_overlap_step + n_per_seg] + * slepian_fcts) + + # Determine Fourier transform of tapered signal + spectrum_estimates = np.abs(np.fft.rfft(tapered_signal, axis=-1))**2 + spectrum_estimates[..., 1:] *= 2 + + # Average Fourier transform windowed signal + psd_segment = np.mean(spectrum_estimates, axis=-2) / fs + + psd_estimates[i] = psd_segment + + psd = np.mean(np.asarray(psd_estimates), axis=0) + + # Attach proper units to return values + if isinstance(signal, pq.quantity.Quantity): + psd = psd * signal.units * signal.units / pq.Hz + freqs = freqs * pq.Hz + + return freqs, psd + + @deprecated_alias(x='signal_i', y='signal_j', num_seg='n_segments', len_seg='len_segment', freq_res='frequency_resolution') def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index d4962834d..314f4baab 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -15,6 +15,7 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal import elephant.spectral +from elephant.test.download import download, ELEPHANT_TMP_DIR class WelchPSDTestCase(unittest.TestCase): @@ -158,6 +159,153 @@ def test_welch_psd_multidim_input(self): self.assertTrue(np.all(psd_neo_1dim == psd_neo[0])) +class MultitaperPSDTestCase(unittest.TestCase): + def test_multitaper_psd_errors(self): + # generate dummy data + signal = n.AnalogSignal(np.zeros(5000), sampling_period=0.001 * pq.s, + units='mV') + fs = 1000 * pq.Hz + nw = 3 + + # check for invalid parameter values + # - number of tapers + self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, + fs, nw, num_tapers=-5) + self.assertRaises(TypeError, elephant.spectral.multitaper_psd, signal, + fs, nw, num_tapers=-5.0) + # - frequency resolution + self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, + fs, nw, peak_resolution=-1) + + def test_multitaper_psd_behavior(self): + # generate data by adding white noise and a sinusoid + data_length = 5000 + sampling_period = 0.001 + signal_freq = 100.0 + noise = np.random.normal(size=data_length) + signal = [np.sin(2 * np.pi * signal_freq * t) + for t in np.arange(0, data_length * sampling_period, + sampling_period)] + data = n.AnalogSignal(np.array(signal + noise), + sampling_period=sampling_period * pq.s, + units='mV') + + # consistency between different ways of specifying number of tapers + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3.5) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3.5, + num_tapers=6) + self.assertTrue((psd1 == psd2).all() and (freqs1 == freqs2).all()) + + # frequency resolution and consistency with data + freq_res = 1.0 * pq.Hz + freqs, psd = elephant.spectral.multitaper_psd( + data, peak_resolution=freq_res) + self.assertEqual(freqs[psd.argmax()], signal_freq) + freqs_np, psd_np = elephant.spectral.multitaper_psd( + data.magnitude.flatten(), fs=1 / sampling_period, + peak_resolution=freq_res) + self.assertTrue((freqs == freqs_np).all() and (psd == psd_np).all()) + + def test_multitaper_psd_parameter_hierarchy(self): + # generate data by adding white noise and a sinusoid + data_length = 5000 + sampling_period = 0.001 + signal_freq = 100.0 + noise = np.random.normal(size=data_length) + signal = [np.sin(2 * np.pi * signal_freq * t) + for t in np.arange(0, data_length * sampling_period, + sampling_period)] + data = n.AnalogSignal(np.array(signal + noise), + sampling_period=sampling_period * pq.s, + units='mV') + + # Test num_tapers vs nw + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3) + self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) + + # Test peak_resolution vs nw + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9, + peak_resolution=1) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9) + self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) + + def test_multitaper_psd_against_nitime(self): + """ + This test assesses the match between this implementation of + multitaper against nitime (0.8) using a predefined time series + generated by an autoregressive model. + + Please follow the link below for more details: + https://gin.g-node.org/INM-6/elephant-data/src/master/unittest/spectral/multitaper_psd + """ + data_url = r"https://web.gin.g-node.org/INM-6/elephant-data/raw/master/unittest/spectral/multitaper_psd/data" # noqa + + files_to_download = [ + ("time_series.npy", "ff43797e2ac94613f510b20a31e2e80e"), + ("psd_nitime.npy", "89d1f53957e66c786049ea425b53c0e8") + ] + + for filename, checksum in files_to_download: + download(url=f"{data_url}/{filename}", checksum=checksum) + + time_series = np.load(ELEPHANT_TMP_DIR / 'time_series.npy') + psd_nitime = np.load(ELEPHANT_TMP_DIR / 'psd_nitime.npy') + + freqs, psd_multitaper = elephant.spectral.multitaper_psd( + signal=time_series, fs=0.1, nw=4, num_tapers=8) + + np.testing.assert_allclose(psd_multitaper, psd_nitime, rtol=0.3, + atol=0.1) + + def test_multitaper_psd_input_types(self): + # generate a test data + sampling_period = 0.001 + data = n.AnalogSignal(np.array(np.random.normal(size=5000)), + sampling_period=sampling_period * pq.s, + units='mV') + + # outputs from AnalogSignal input are of Quantity type (standard usage) + freqs_neo, psd_neo = elephant.spectral.multitaper_psd(data) + self.assertTrue(isinstance(freqs_neo, pq.quantity.Quantity)) + self.assertTrue(isinstance(psd_neo, pq.quantity.Quantity)) + + # outputs from Quantity array input are of Quantity type + freqs_pq, psd_pq = elephant.spectral.multitaper_psd( + data.magnitude.flatten() * data.units, fs=1 / sampling_period) + self.assertTrue(isinstance(freqs_pq, pq.quantity.Quantity)) + self.assertTrue(isinstance(psd_pq, pq.quantity.Quantity)) + + # outputs from Numpy ndarray input are NOT of Quantity type + freqs_np, psd_np = elephant.spectral.multitaper_psd( + data.magnitude.flatten(), fs=1 / sampling_period) + self.assertFalse(isinstance(freqs_np, pq.quantity.Quantity)) + self.assertFalse(isinstance(psd_np, pq.quantity.Quantity)) + + # check if the results from different input types are identical + self.assertTrue( + (freqs_neo == freqs_pq).all() and ( + psd_neo == psd_pq).all()) + self.assertTrue( + (freqs_neo == freqs_np).all() and ( + psd_neo == psd_np).all()) + + class WelchCohereTestCase(unittest.TestCase): def test_welch_cohere_errors(self): # generate a dummy data From 8a284ad975c5105ac0a864cc06e44236fa890c65 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 23 Feb 2022 13:30:51 +0100 Subject: [PATCH 37/63] Revert "Feature/multitaper psd estimate (#417)" (#457) This reverts commit d0d39206a5a2bff0d57d365a63a30e402dbc597d to fix an issue where the authors of #417 where incorrectly identified. #417 will be re-merged with correct author attributions. --- elephant/spectral.py | 246 --------------------------------- elephant/test/test_spectral.py | 148 -------------------- 2 files changed, 394 deletions(-) diff --git a/elephant/spectral.py b/elephant/spectral.py index 661cac76e..cd41ea471 100644 --- a/elephant/spectral.py +++ b/elephant/spectral.py @@ -270,252 +270,6 @@ def welch_psd(signal, n_segments=8, len_segment=None, return freqs, psd -def multitaper_psd(signal, n_segments=1, len_segment=None, - frequency_resolution=None, overlap=0.5, fs=1, - nw=4, num_tapers=None, peak_resolution=None, axis=-1): - """ - Estimates power spectrum density (PSD) of a given 'neo.AnalogSignal' - using Multitaper method - - The PSD is obtained through the following steps: - - 1. Cut the given data into several overlapping segments. The degree of - overlap can be specified by parameter `overlap` (default is 0.5, - i.e. segments are overlapped by the half of their length). - The number and the length of the segments are determined according - to the parameters `n_segments`, `len_segment` or `frequency_resolution`. - By default, the data is cut into 8 segments; - - 2. Calculate 'num_tapers' approximately independent estimates of the - spectrum by multiplying the signal with the discrete prolate spheroidal - functions (also known as Slepian function) and calculate the PSD of each - tapered segment - - 3. Average the approximately independent estimates of each segment to - decrease overall variance of the estimates - - 4. Average the obtained estimates for each segment - - Parameters - ---------- - signal : neo.AnalogSignal - Time series data of which PSD is estimated. When `signal` is np.ndarray - sampling frequency should be given through keyword argument `fs`. - Signal should be passed as (n_channels, n_samples) - fs : float, optional - Specifies the sampling frequency of the input time series - Default: 1.0. - n_segments : int, optional - Number of segments. The length of segments is adjusted so that - overlapping segments cover the entire stretch of the given data. This - parameter is ignored if `len_segment` or `frequency_resolution` is - given. - Default: 8. - len_segment : int, optional - Length of segments. This parameter is ignored if `frequency_resolution` - is given. If None, it will be determined from other parameters. - Default: None. - frequency_resolution : pq.Quantity or float, optional - Desired frequency resolution of the obtained PSD estimate in terms of - the interval between adjacent frequency bins. When given as a `float`, - it is taken as frequency in Hz. - If None, it will be determined from other parameters. - Default: None. - overlap : float, optional - Overlap between segments represented as a float number between 0 (no - overlap) and 1 (complete overlap). - Default: 0.5 (half-overlapped). - nw : float, optional - Time bandwidth product - Default: 4.0. - num_tapers : int, optional - Number of tapers used in 1. to obtain estimate of PSD. By default - [2*nw] - 1 is chosen. - Default: None. - peak_resolution : pq.Quantity float, optional - Quantity in Hz determining the number of tapers used for analysis. - Fine peak resolution --> low numerical value --> low number of tapers - High peak resolution --> high numerical value --> high number of tapers - When given as a `float`, it is taken as frequency in Hz. - Default: None. - axis : int, optional - Axis along which the periodogram is computed. - See Notes [2]. - Default: last axis (-1). - - Notes - ----- - 1. There is a parameter hierarchy regarding n_segments and len_segment. The - former parameter is ignored if the latter one is passed. - - 2. There is a parameter hierarchy regarding nw, num_tapers and - peak_resolution. If peak_resolution is provided, it determines both nw - and the num_tapers. Specifying num_tapers has an effect only if - peak_resolution is not provided. - - Returns - ------- - freqs : np.ndarray - Frequencies associated with power estimate in `psd` - psd : np.ndarray - PSD estimate of the time series in `signal` - - Raises - ------ - ValueError - If `peak_resolution` is None and `num_tapers` is not a positive number. - - If `frequency_resolution` is too high for the given data size. - - If `frequency_resolution` is None and `len_segment` is not a positive - number. - - If `frequency_resolution` is None and `len_segment` is greater than the - length of data at `axis`. - - If both `frequency_resolution` and `len_segment` are None and - `n_segments` is not a positive number. - - If both `frequency_resolution` and `len_segment` are None and - `n_segments` is greater than the length of data at `axis`. - - TypeError - If `peak_resolution` is None and `num_tapers` is not an int. - """ - - # When the input is AnalogSignal, the data is added after rolling the axis - # for time index to the last - data = np.asarray(signal) - if isinstance(signal, neo.AnalogSignal): - data = np.rollaxis(data, 0, len(data.shape)) - - # Number of data points in time series - if data.ndim == 1: - length_signal = np.shape(data)[0] - else: - length_signal = np.shape(data)[1] - - # If the data is given as AnalogSignal, use its attribute to specify the - # sampling frequency - if hasattr(signal, 'sampling_rate'): - fs = signal.sampling_rate.rescale('Hz').magnitude - - # If fs and peak resolution is pq.Quantity, get magnitude - if isinstance(fs, pq.quantity.Quantity): - fs = fs.rescale('Hz').magnitude - - # Determine length per segment - n_per_seg - if frequency_resolution is not None: - if frequency_resolution <= 0: - raise ValueError("frequency_resolution must be positive") - if isinstance(frequency_resolution, pq.quantity.Quantity): - dF = frequency_resolution.rescale('Hz').magnitude - else: - dF = frequency_resolution - n_per_seg = int(fs / dF) - if n_per_seg > data.shape[axis]: - raise ValueError("frequency_resolution is too high for the given " - "data size") - elif len_segment is not None: - if len_segment <= 0: - raise ValueError("len_seg must be a positive number") - elif data.shape[axis] < len_segment: - raise ValueError("len_seg must be shorter than the data length") - n_per_seg = len_segment - else: - if n_segments <= 0: - raise ValueError("n_segments must be a positive number") - elif data.shape[axis] < n_segments: - raise ValueError("n_segments must be smaller than the data length") - # when only *n_segments* is given, *n_per_seg* is determined by solving - # the following equation: - # n_segments * n_per_seg - (n_segments-1) * overlap * n_per_seg = - # data.shape[-1] - # -------------------- =============================== ^^^^^^^^^^^ - # summed segment lengths total overlap data length - n_per_seg = int(data.shape[axis] / - (n_segments - overlap * (n_segments - 1))) - - n_overlap = int(n_per_seg * overlap) - n_segments = int((length_signal - n_overlap) / (n_per_seg - n_overlap)) - - if isinstance(peak_resolution, pq.quantity.Quantity): - peak_resolution = peak_resolution.rescale('Hz').magnitude - - # Determine time-halfbandwidth product from given parameters - if peak_resolution is not None: - if peak_resolution <= 0: - raise ValueError("peak_resolution must be positive") - nw = n_per_seg / fs * peak_resolution / 2 - num_tapers = int(np.floor(2*nw) - 1) - - if num_tapers is None: - num_tapers = int(np.floor(2*nw) - 1) - else: - if not isinstance(num_tapers, int): - raise TypeError("num_tapers must be integer") - if num_tapers <= 0: - raise ValueError("num_tapers must be positive") - - # Generate frequencies of PSD estimate - freqs = np.fft.rfftfreq(n_per_seg, d=1/fs) - - # Zero-pad signal to fit segment length - remainder = length_signal % n_per_seg - - if data.ndim == 1: - data = np.pad(data, pad_width=(0, remainder), - mode='constant', constant_values=0) - # Generate array for storing PSD estimates of segments - psd_estimates = np.zeros((n_segments, len(freqs))) - else: - data = np.pad(data, [(0, 0), (0, remainder)], - mode='constant', constant_values=0) - # Generate array for storing PSD estimates of segments - psd_estimates = np.zeros((n_segments, data.shape[0], len(freqs))) - - # Determine the number of samples given overlap - n_overlap_step = n_per_seg - n_overlap - - for i in range(n_segments): - # Get slepian functions (sym=False used for spectral analysis) - slepian_fcts = scipy.signal.windows.dpss(M=n_per_seg, - NW=nw, - Kmax=num_tapers, - sym=False) - - # Calculate approximately independent spectrum estimates - if data.ndim == 1: - tapered_signal = (data[i * n_overlap_step: - i * n_overlap_step + n_per_seg] - * slepian_fcts) - else: - # Use broadcasting to match dim for point-wise multiplication - tapered_signal = (data[:, - np.newaxis, - i * n_overlap_step: - i * n_overlap_step + n_per_seg] - * slepian_fcts) - - # Determine Fourier transform of tapered signal - spectrum_estimates = np.abs(np.fft.rfft(tapered_signal, axis=-1))**2 - spectrum_estimates[..., 1:] *= 2 - - # Average Fourier transform windowed signal - psd_segment = np.mean(spectrum_estimates, axis=-2) / fs - - psd_estimates[i] = psd_segment - - psd = np.mean(np.asarray(psd_estimates), axis=0) - - # Attach proper units to return values - if isinstance(signal, pq.quantity.Quantity): - psd = psd * signal.units * signal.units / pq.Hz - freqs = freqs * pq.Hz - - return freqs, psd - - @deprecated_alias(x='signal_i', y='signal_j', num_seg='n_segments', len_seg='len_segment', freq_res='frequency_resolution') def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index 314f4baab..d4962834d 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -15,7 +15,6 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal import elephant.spectral -from elephant.test.download import download, ELEPHANT_TMP_DIR class WelchPSDTestCase(unittest.TestCase): @@ -159,153 +158,6 @@ def test_welch_psd_multidim_input(self): self.assertTrue(np.all(psd_neo_1dim == psd_neo[0])) -class MultitaperPSDTestCase(unittest.TestCase): - def test_multitaper_psd_errors(self): - # generate dummy data - signal = n.AnalogSignal(np.zeros(5000), sampling_period=0.001 * pq.s, - units='mV') - fs = 1000 * pq.Hz - nw = 3 - - # check for invalid parameter values - # - number of tapers - self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, - fs, nw, num_tapers=-5) - self.assertRaises(TypeError, elephant.spectral.multitaper_psd, signal, - fs, nw, num_tapers=-5.0) - # - frequency resolution - self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, - fs, nw, peak_resolution=-1) - - def test_multitaper_psd_behavior(self): - # generate data by adding white noise and a sinusoid - data_length = 5000 - sampling_period = 0.001 - signal_freq = 100.0 - noise = np.random.normal(size=data_length) - signal = [np.sin(2 * np.pi * signal_freq * t) - for t in np.arange(0, data_length * sampling_period, - sampling_period)] - data = n.AnalogSignal(np.array(signal + noise), - sampling_period=sampling_period * pq.s, - units='mV') - - # consistency between different ways of specifying number of tapers - freqs1, psd1 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3.5) - freqs2, psd2 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3.5, - num_tapers=6) - self.assertTrue((psd1 == psd2).all() and (freqs1 == freqs2).all()) - - # frequency resolution and consistency with data - freq_res = 1.0 * pq.Hz - freqs, psd = elephant.spectral.multitaper_psd( - data, peak_resolution=freq_res) - self.assertEqual(freqs[psd.argmax()], signal_freq) - freqs_np, psd_np = elephant.spectral.multitaper_psd( - data.magnitude.flatten(), fs=1 / sampling_period, - peak_resolution=freq_res) - self.assertTrue((freqs == freqs_np).all() and (psd == psd_np).all()) - - def test_multitaper_psd_parameter_hierarchy(self): - # generate data by adding white noise and a sinusoid - data_length = 5000 - sampling_period = 0.001 - signal_freq = 100.0 - noise = np.random.normal(size=data_length) - signal = [np.sin(2 * np.pi * signal_freq * t) - for t in np.arange(0, data_length * sampling_period, - sampling_period)] - data = n.AnalogSignal(np.array(signal + noise), - sampling_period=sampling_period * pq.s, - units='mV') - - # Test num_tapers vs nw - freqs1, psd1 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3, - num_tapers=9) - freqs2, psd2 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3) - self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) - - # Test peak_resolution vs nw - freqs1, psd1 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3, - num_tapers=9, - peak_resolution=1) - freqs2, psd2 = elephant.spectral.multitaper_psd(data, - fs=data.sampling_rate, - nw=3, - num_tapers=9) - self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) - - def test_multitaper_psd_against_nitime(self): - """ - This test assesses the match between this implementation of - multitaper against nitime (0.8) using a predefined time series - generated by an autoregressive model. - - Please follow the link below for more details: - https://gin.g-node.org/INM-6/elephant-data/src/master/unittest/spectral/multitaper_psd - """ - data_url = r"https://web.gin.g-node.org/INM-6/elephant-data/raw/master/unittest/spectral/multitaper_psd/data" # noqa - - files_to_download = [ - ("time_series.npy", "ff43797e2ac94613f510b20a31e2e80e"), - ("psd_nitime.npy", "89d1f53957e66c786049ea425b53c0e8") - ] - - for filename, checksum in files_to_download: - download(url=f"{data_url}/{filename}", checksum=checksum) - - time_series = np.load(ELEPHANT_TMP_DIR / 'time_series.npy') - psd_nitime = np.load(ELEPHANT_TMP_DIR / 'psd_nitime.npy') - - freqs, psd_multitaper = elephant.spectral.multitaper_psd( - signal=time_series, fs=0.1, nw=4, num_tapers=8) - - np.testing.assert_allclose(psd_multitaper, psd_nitime, rtol=0.3, - atol=0.1) - - def test_multitaper_psd_input_types(self): - # generate a test data - sampling_period = 0.001 - data = n.AnalogSignal(np.array(np.random.normal(size=5000)), - sampling_period=sampling_period * pq.s, - units='mV') - - # outputs from AnalogSignal input are of Quantity type (standard usage) - freqs_neo, psd_neo = elephant.spectral.multitaper_psd(data) - self.assertTrue(isinstance(freqs_neo, pq.quantity.Quantity)) - self.assertTrue(isinstance(psd_neo, pq.quantity.Quantity)) - - # outputs from Quantity array input are of Quantity type - freqs_pq, psd_pq = elephant.spectral.multitaper_psd( - data.magnitude.flatten() * data.units, fs=1 / sampling_period) - self.assertTrue(isinstance(freqs_pq, pq.quantity.Quantity)) - self.assertTrue(isinstance(psd_pq, pq.quantity.Quantity)) - - # outputs from Numpy ndarray input are NOT of Quantity type - freqs_np, psd_np = elephant.spectral.multitaper_psd( - data.magnitude.flatten(), fs=1 / sampling_period) - self.assertFalse(isinstance(freqs_np, pq.quantity.Quantity)) - self.assertFalse(isinstance(psd_np, pq.quantity.Quantity)) - - # check if the results from different input types are identical - self.assertTrue( - (freqs_neo == freqs_pq).all() and ( - psd_neo == psd_pq).all()) - self.assertTrue( - (freqs_neo == freqs_np).all() and ( - psd_neo == psd_np).all()) - - class WelchCohereTestCase(unittest.TestCase): def test_welch_cohere_errors(self): # generate a dummy data From b263ffe80e5ab759288ad25331cde4f6a359f3ec Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 25 Feb 2022 12:32:49 +0100 Subject: [PATCH 38/63] Feature/multitaper psd estimate (#458) New Feature: multitaper psd estimate. Tests include a comparison against nitime multitaper. Co-authored-by: ackurth Co-authored-by: Regimantas Jurkus Co-authored-by: Aitor Morales-Gregorio <43403140+morales-gregorio@users.noreply.github.com> Co-authored-by: kleinjohann Co-authored-by: pbouss <34713558+pbouss@users.noreply.github.com> Co-authored-by: Danylo Ulianych Co-authored-by: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> Co-authored-by: Andrew Davison Co-authored-by: Anno Christopher Kurth <44397333+ackurth@users.noreply.github.com> --- elephant/spectral.py | 246 +++++++++++++++++++++++++++++++++ elephant/test/test_spectral.py | 148 ++++++++++++++++++++ 2 files changed, 394 insertions(+) diff --git a/elephant/spectral.py b/elephant/spectral.py index cd41ea471..661cac76e 100644 --- a/elephant/spectral.py +++ b/elephant/spectral.py @@ -270,6 +270,252 @@ def welch_psd(signal, n_segments=8, len_segment=None, return freqs, psd +def multitaper_psd(signal, n_segments=1, len_segment=None, + frequency_resolution=None, overlap=0.5, fs=1, + nw=4, num_tapers=None, peak_resolution=None, axis=-1): + """ + Estimates power spectrum density (PSD) of a given 'neo.AnalogSignal' + using Multitaper method + + The PSD is obtained through the following steps: + + 1. Cut the given data into several overlapping segments. The degree of + overlap can be specified by parameter `overlap` (default is 0.5, + i.e. segments are overlapped by the half of their length). + The number and the length of the segments are determined according + to the parameters `n_segments`, `len_segment` or `frequency_resolution`. + By default, the data is cut into 8 segments; + + 2. Calculate 'num_tapers' approximately independent estimates of the + spectrum by multiplying the signal with the discrete prolate spheroidal + functions (also known as Slepian function) and calculate the PSD of each + tapered segment + + 3. Average the approximately independent estimates of each segment to + decrease overall variance of the estimates + + 4. Average the obtained estimates for each segment + + Parameters + ---------- + signal : neo.AnalogSignal + Time series data of which PSD is estimated. When `signal` is np.ndarray + sampling frequency should be given through keyword argument `fs`. + Signal should be passed as (n_channels, n_samples) + fs : float, optional + Specifies the sampling frequency of the input time series + Default: 1.0. + n_segments : int, optional + Number of segments. The length of segments is adjusted so that + overlapping segments cover the entire stretch of the given data. This + parameter is ignored if `len_segment` or `frequency_resolution` is + given. + Default: 8. + len_segment : int, optional + Length of segments. This parameter is ignored if `frequency_resolution` + is given. If None, it will be determined from other parameters. + Default: None. + frequency_resolution : pq.Quantity or float, optional + Desired frequency resolution of the obtained PSD estimate in terms of + the interval between adjacent frequency bins. When given as a `float`, + it is taken as frequency in Hz. + If None, it will be determined from other parameters. + Default: None. + overlap : float, optional + Overlap between segments represented as a float number between 0 (no + overlap) and 1 (complete overlap). + Default: 0.5 (half-overlapped). + nw : float, optional + Time bandwidth product + Default: 4.0. + num_tapers : int, optional + Number of tapers used in 1. to obtain estimate of PSD. By default + [2*nw] - 1 is chosen. + Default: None. + peak_resolution : pq.Quantity float, optional + Quantity in Hz determining the number of tapers used for analysis. + Fine peak resolution --> low numerical value --> low number of tapers + High peak resolution --> high numerical value --> high number of tapers + When given as a `float`, it is taken as frequency in Hz. + Default: None. + axis : int, optional + Axis along which the periodogram is computed. + See Notes [2]. + Default: last axis (-1). + + Notes + ----- + 1. There is a parameter hierarchy regarding n_segments and len_segment. The + former parameter is ignored if the latter one is passed. + + 2. There is a parameter hierarchy regarding nw, num_tapers and + peak_resolution. If peak_resolution is provided, it determines both nw + and the num_tapers. Specifying num_tapers has an effect only if + peak_resolution is not provided. + + Returns + ------- + freqs : np.ndarray + Frequencies associated with power estimate in `psd` + psd : np.ndarray + PSD estimate of the time series in `signal` + + Raises + ------ + ValueError + If `peak_resolution` is None and `num_tapers` is not a positive number. + + If `frequency_resolution` is too high for the given data size. + + If `frequency_resolution` is None and `len_segment` is not a positive + number. + + If `frequency_resolution` is None and `len_segment` is greater than the + length of data at `axis`. + + If both `frequency_resolution` and `len_segment` are None and + `n_segments` is not a positive number. + + If both `frequency_resolution` and `len_segment` are None and + `n_segments` is greater than the length of data at `axis`. + + TypeError + If `peak_resolution` is None and `num_tapers` is not an int. + """ + + # When the input is AnalogSignal, the data is added after rolling the axis + # for time index to the last + data = np.asarray(signal) + if isinstance(signal, neo.AnalogSignal): + data = np.rollaxis(data, 0, len(data.shape)) + + # Number of data points in time series + if data.ndim == 1: + length_signal = np.shape(data)[0] + else: + length_signal = np.shape(data)[1] + + # If the data is given as AnalogSignal, use its attribute to specify the + # sampling frequency + if hasattr(signal, 'sampling_rate'): + fs = signal.sampling_rate.rescale('Hz').magnitude + + # If fs and peak resolution is pq.Quantity, get magnitude + if isinstance(fs, pq.quantity.Quantity): + fs = fs.rescale('Hz').magnitude + + # Determine length per segment - n_per_seg + if frequency_resolution is not None: + if frequency_resolution <= 0: + raise ValueError("frequency_resolution must be positive") + if isinstance(frequency_resolution, pq.quantity.Quantity): + dF = frequency_resolution.rescale('Hz').magnitude + else: + dF = frequency_resolution + n_per_seg = int(fs / dF) + if n_per_seg > data.shape[axis]: + raise ValueError("frequency_resolution is too high for the given " + "data size") + elif len_segment is not None: + if len_segment <= 0: + raise ValueError("len_seg must be a positive number") + elif data.shape[axis] < len_segment: + raise ValueError("len_seg must be shorter than the data length") + n_per_seg = len_segment + else: + if n_segments <= 0: + raise ValueError("n_segments must be a positive number") + elif data.shape[axis] < n_segments: + raise ValueError("n_segments must be smaller than the data length") + # when only *n_segments* is given, *n_per_seg* is determined by solving + # the following equation: + # n_segments * n_per_seg - (n_segments-1) * overlap * n_per_seg = + # data.shape[-1] + # -------------------- =============================== ^^^^^^^^^^^ + # summed segment lengths total overlap data length + n_per_seg = int(data.shape[axis] / + (n_segments - overlap * (n_segments - 1))) + + n_overlap = int(n_per_seg * overlap) + n_segments = int((length_signal - n_overlap) / (n_per_seg - n_overlap)) + + if isinstance(peak_resolution, pq.quantity.Quantity): + peak_resolution = peak_resolution.rescale('Hz').magnitude + + # Determine time-halfbandwidth product from given parameters + if peak_resolution is not None: + if peak_resolution <= 0: + raise ValueError("peak_resolution must be positive") + nw = n_per_seg / fs * peak_resolution / 2 + num_tapers = int(np.floor(2*nw) - 1) + + if num_tapers is None: + num_tapers = int(np.floor(2*nw) - 1) + else: + if not isinstance(num_tapers, int): + raise TypeError("num_tapers must be integer") + if num_tapers <= 0: + raise ValueError("num_tapers must be positive") + + # Generate frequencies of PSD estimate + freqs = np.fft.rfftfreq(n_per_seg, d=1/fs) + + # Zero-pad signal to fit segment length + remainder = length_signal % n_per_seg + + if data.ndim == 1: + data = np.pad(data, pad_width=(0, remainder), + mode='constant', constant_values=0) + # Generate array for storing PSD estimates of segments + psd_estimates = np.zeros((n_segments, len(freqs))) + else: + data = np.pad(data, [(0, 0), (0, remainder)], + mode='constant', constant_values=0) + # Generate array for storing PSD estimates of segments + psd_estimates = np.zeros((n_segments, data.shape[0], len(freqs))) + + # Determine the number of samples given overlap + n_overlap_step = n_per_seg - n_overlap + + for i in range(n_segments): + # Get slepian functions (sym=False used for spectral analysis) + slepian_fcts = scipy.signal.windows.dpss(M=n_per_seg, + NW=nw, + Kmax=num_tapers, + sym=False) + + # Calculate approximately independent spectrum estimates + if data.ndim == 1: + tapered_signal = (data[i * n_overlap_step: + i * n_overlap_step + n_per_seg] + * slepian_fcts) + else: + # Use broadcasting to match dim for point-wise multiplication + tapered_signal = (data[:, + np.newaxis, + i * n_overlap_step: + i * n_overlap_step + n_per_seg] + * slepian_fcts) + + # Determine Fourier transform of tapered signal + spectrum_estimates = np.abs(np.fft.rfft(tapered_signal, axis=-1))**2 + spectrum_estimates[..., 1:] *= 2 + + # Average Fourier transform windowed signal + psd_segment = np.mean(spectrum_estimates, axis=-2) / fs + + psd_estimates[i] = psd_segment + + psd = np.mean(np.asarray(psd_estimates), axis=0) + + # Attach proper units to return values + if isinstance(signal, pq.quantity.Quantity): + psd = psd * signal.units * signal.units / pq.Hz + freqs = freqs * pq.Hz + + return freqs, psd + + @deprecated_alias(x='signal_i', y='signal_j', num_seg='n_segments', len_seg='len_segment', freq_res='frequency_resolution') def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index d4962834d..314f4baab 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -15,6 +15,7 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal import elephant.spectral +from elephant.test.download import download, ELEPHANT_TMP_DIR class WelchPSDTestCase(unittest.TestCase): @@ -158,6 +159,153 @@ def test_welch_psd_multidim_input(self): self.assertTrue(np.all(psd_neo_1dim == psd_neo[0])) +class MultitaperPSDTestCase(unittest.TestCase): + def test_multitaper_psd_errors(self): + # generate dummy data + signal = n.AnalogSignal(np.zeros(5000), sampling_period=0.001 * pq.s, + units='mV') + fs = 1000 * pq.Hz + nw = 3 + + # check for invalid parameter values + # - number of tapers + self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, + fs, nw, num_tapers=-5) + self.assertRaises(TypeError, elephant.spectral.multitaper_psd, signal, + fs, nw, num_tapers=-5.0) + # - frequency resolution + self.assertRaises(ValueError, elephant.spectral.multitaper_psd, signal, + fs, nw, peak_resolution=-1) + + def test_multitaper_psd_behavior(self): + # generate data by adding white noise and a sinusoid + data_length = 5000 + sampling_period = 0.001 + signal_freq = 100.0 + noise = np.random.normal(size=data_length) + signal = [np.sin(2 * np.pi * signal_freq * t) + for t in np.arange(0, data_length * sampling_period, + sampling_period)] + data = n.AnalogSignal(np.array(signal + noise), + sampling_period=sampling_period * pq.s, + units='mV') + + # consistency between different ways of specifying number of tapers + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3.5) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3.5, + num_tapers=6) + self.assertTrue((psd1 == psd2).all() and (freqs1 == freqs2).all()) + + # frequency resolution and consistency with data + freq_res = 1.0 * pq.Hz + freqs, psd = elephant.spectral.multitaper_psd( + data, peak_resolution=freq_res) + self.assertEqual(freqs[psd.argmax()], signal_freq) + freqs_np, psd_np = elephant.spectral.multitaper_psd( + data.magnitude.flatten(), fs=1 / sampling_period, + peak_resolution=freq_res) + self.assertTrue((freqs == freqs_np).all() and (psd == psd_np).all()) + + def test_multitaper_psd_parameter_hierarchy(self): + # generate data by adding white noise and a sinusoid + data_length = 5000 + sampling_period = 0.001 + signal_freq = 100.0 + noise = np.random.normal(size=data_length) + signal = [np.sin(2 * np.pi * signal_freq * t) + for t in np.arange(0, data_length * sampling_period, + sampling_period)] + data = n.AnalogSignal(np.array(signal + noise), + sampling_period=sampling_period * pq.s, + units='mV') + + # Test num_tapers vs nw + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3) + self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) + + # Test peak_resolution vs nw + freqs1, psd1 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9, + peak_resolution=1) + freqs2, psd2 = elephant.spectral.multitaper_psd(data, + fs=data.sampling_rate, + nw=3, + num_tapers=9) + self.assertTrue((freqs1 == freqs2).all() and (psd1 != psd2).all()) + + def test_multitaper_psd_against_nitime(self): + """ + This test assesses the match between this implementation of + multitaper against nitime (0.8) using a predefined time series + generated by an autoregressive model. + + Please follow the link below for more details: + https://gin.g-node.org/INM-6/elephant-data/src/master/unittest/spectral/multitaper_psd + """ + data_url = r"https://web.gin.g-node.org/INM-6/elephant-data/raw/master/unittest/spectral/multitaper_psd/data" # noqa + + files_to_download = [ + ("time_series.npy", "ff43797e2ac94613f510b20a31e2e80e"), + ("psd_nitime.npy", "89d1f53957e66c786049ea425b53c0e8") + ] + + for filename, checksum in files_to_download: + download(url=f"{data_url}/{filename}", checksum=checksum) + + time_series = np.load(ELEPHANT_TMP_DIR / 'time_series.npy') + psd_nitime = np.load(ELEPHANT_TMP_DIR / 'psd_nitime.npy') + + freqs, psd_multitaper = elephant.spectral.multitaper_psd( + signal=time_series, fs=0.1, nw=4, num_tapers=8) + + np.testing.assert_allclose(psd_multitaper, psd_nitime, rtol=0.3, + atol=0.1) + + def test_multitaper_psd_input_types(self): + # generate a test data + sampling_period = 0.001 + data = n.AnalogSignal(np.array(np.random.normal(size=5000)), + sampling_period=sampling_period * pq.s, + units='mV') + + # outputs from AnalogSignal input are of Quantity type (standard usage) + freqs_neo, psd_neo = elephant.spectral.multitaper_psd(data) + self.assertTrue(isinstance(freqs_neo, pq.quantity.Quantity)) + self.assertTrue(isinstance(psd_neo, pq.quantity.Quantity)) + + # outputs from Quantity array input are of Quantity type + freqs_pq, psd_pq = elephant.spectral.multitaper_psd( + data.magnitude.flatten() * data.units, fs=1 / sampling_period) + self.assertTrue(isinstance(freqs_pq, pq.quantity.Quantity)) + self.assertTrue(isinstance(psd_pq, pq.quantity.Quantity)) + + # outputs from Numpy ndarray input are NOT of Quantity type + freqs_np, psd_np = elephant.spectral.multitaper_psd( + data.magnitude.flatten(), fs=1 / sampling_period) + self.assertFalse(isinstance(freqs_np, pq.quantity.Quantity)) + self.assertFalse(isinstance(psd_np, pq.quantity.Quantity)) + + # check if the results from different input types are identical + self.assertTrue( + (freqs_neo == freqs_pq).all() and ( + psd_neo == psd_pq).all()) + self.assertTrue( + (freqs_neo == freqs_np).all() and ( + psd_neo == psd_np).all()) + + class WelchCohereTestCase(unittest.TestCase): def test_welch_cohere_errors(self): # generate a dummy data From 0074a14bf6380d485e047d847efff69d1d965d98 Mon Sep 17 00:00:00 2001 From: Alexander Kleinjohann <33096371+Kleinjohann@users.noreply.github.com> Date: Tue, 8 Mar 2022 14:41:00 +0100 Subject: [PATCH 39/63] Add a function to discretise spiketimes (#454) added `discretise_spiketimes(spiketrains, sampling_rate)` to conversion --- elephant/conversion.py | 66 ++++++++++++++++++++++++++++++++ elephant/test/test_conversion.py | 38 ++++++++++++++++++ 2 files changed, 104 insertions(+) diff --git a/elephant/conversion.py b/elephant/conversion.py index 0c9615258..a0aae2a28 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -1246,3 +1246,69 @@ def _check_neo_spiketrain(matrix): if isinstance(matrix, (list, tuple)): return all(map(_check_neo_spiketrain, matrix)) return False + + +def discretise_spiketimes(spiketrains, sampling_rate): + """ + Rounds down all spike times in the input spike train(s) + to multiples of the sampling_rate + + Parameters + ---------- + spiketrains : neo.SpikeTrain or list of neo.SpikeTrain + The spiketrain(s) to discretise + sampling_rate : pq.Quantity + The desired sampling rate + + Returns + ------- + neo.SpikeTrain or list of neo.SpikeTrain + The discretised spiketrain(s) + """ + # spiketrains type check + was_single_spiketrain = False + if isinstance(spiketrains, neo.SpikeTrain): + spiketrains = [spiketrains] + was_single_spiketrain = True + elif isinstance(spiketrains, list): + for st in spiketrains: + if not isinstance(st, (np.ndarray, neo.SpikeTrain)): + raise TypeError( + "spiketrains must be a SpikeTrain, a numpy ndarray, or a " + "list of one of those, not %s." % type(spiketrains)) + else: + raise TypeError( + "spiketrains must be a SpikeTrain or a list of SpikeTrain objects," + " not %s." % type(spiketrains)) + + if not isinstance(sampling_rate, pq.Quantity): + raise TypeError( + "The 'sampling_rate' must be pq.Quantity.\n" + "Found: %s." % type(sampling_rate)) + + units = spiketrains[0].times.units + mag_sampling_rate = sampling_rate.rescale(1/units).magnitude.flatten() + + new_spiketrains = [] + for spiketrain in spiketrains: + mag_t_start = spiketrain.t_start.rescale(units).magnitude.flatten() + mag_times = spiketrain.times.magnitude.flatten() + discrete_times = (mag_times // (1 / mag_sampling_rate) + / mag_sampling_rate) + mask = discrete_times < mag_t_start + + if np.any(mask): + warnings.warn(f'{mask.sum()} spike(s) would be before t_start ' + 'and are set to t_start instead.') + discrete_times[mask] = mag_t_start + + discrete_times *= units + new_spiketrain = spiketrain.duplicate_with_new_data(discrete_times) + new_spiketrain.annotations = spiketrain.annotations + new_spiketrain.sampling_rate = sampling_rate + new_spiketrains.append(new_spiketrain) + + if was_single_spiketrain: + new_spiketrains = new_spiketrains[0] + + return new_spiketrains diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index db5cae06e..d0fde16b7 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -702,5 +702,43 @@ def test_binned_spiketrain_rounding(self): np.arange(120000)) +class DiscretiseSpiketrainsTestCase(unittest.TestCase): + def setUp(self): + times = (np.arange(10) + np.random.uniform(size=10)) * pq.ms + self.spiketrains = [neo.SpikeTrain(times, t_stop=10*pq.ms)] * 5 + + def test_list_of_spiketrains(self): + discretised_spiketrains = cv.discretise_spiketimes(self.spiketrains, + 1 / pq.ms) + for idx in range(len(self.spiketrains)): + np.testing.assert_array_equal(discretised_spiketrains[idx].times, + np.arange(10) * pq.ms) + + def test_single_spiketrain(self): + discretised_spiketrain = cv.discretise_spiketimes(self.spiketrains[0], + 1 / pq.ms) + np.testing.assert_array_equal(discretised_spiketrain.times, + np.arange(10) * pq.ms) + + def test_preserve_t_start(self): + spiketrain = neo.SpikeTrain([0.7, 5.1]*pq.ms, + t_start=0.5*pq.ms, t_stop=10*pq.ms) + with self.assertWarns(UserWarning): + discretised_spiketrain = cv.discretise_spiketimes(spiketrain, + 1 / pq.ms) + np.testing.assert_array_equal(discretised_spiketrain.times, + [0.5, 5] * pq.ms) + + def test_binning_consistency(self): + discretised_spiketrains = cv.discretise_spiketimes(self.spiketrains, + 1 / pq.ms) + bsts = cv.BinnedSpikeTrain(self.spiketrains, + bin_size=1 * pq.ms) + bsts_discretised = cv.BinnedSpikeTrain(discretised_spiketrains, + bin_size=1 * pq.ms) + np.testing.assert_array_equal(bsts.to_array(), + bsts_discretised.to_array()) + + if __name__ == '__main__': unittest.main() From 5be9d7fbfedda46e13baf332ef569d3cd072b10c Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 14 Mar 2022 08:08:54 +0100 Subject: [PATCH 40/63] Support SpikeTrainList object and deprecate RecordingChannel in Elephant (#447) * Handle SpikeTrainList as input for BinnedSpikeTrain * Add corresponding regression test * PEP 8; avoid universal try-except clause * Fixed SpikeTrainList issue in spike train synchrony class * Fixed SpikeTrainList issue in SPADE * Pep8 issue * This removes support of RrcordingChannelGroup in CSD methods. * Changed requirements to Neo >=0.10.0 * Fix spiketrain lists in instantaneous rate. --- elephant/conversion.py | 17 ++++++---- elephant/current_source_density.py | 51 ++++++++++++++++-------------- elephant/spade.py | 3 +- elephant/spike_train_synchrony.py | 6 +++- elephant/statistics.py | 3 +- elephant/test/test_conversion.py | 23 ++++++++++++++ elephant/test/test_kcsd.py | 18 ++--------- elephant/test/test_spade.py | 30 ++++++++++++++++++ elephant/utils.py | 3 +- requirements/requirements.txt | 2 +- 10 files changed, 106 insertions(+), 50 deletions(-) diff --git a/elephant/conversion.py b/elephant/conversion.py index a0aae2a28..adb070865 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -1223,14 +1223,14 @@ def __init__(self, t_start, t_stop, bin_size, units, sparse_matrix, self.tolerance = tolerance -def _check_neo_spiketrain(matrix): +def _check_neo_spiketrain(query): """ Checks if given input contains neo.SpikeTrain objects Parameters ---------- - matrix - Object to test for `neo.SpikeTrain`s + query + Object to test for `neo.SpikeTrain` objects Returns ------- @@ -1240,11 +1240,14 @@ def _check_neo_spiketrain(matrix): """ # Check for single spike train - if isinstance(matrix, neo.SpikeTrain): + if isinstance(query, neo.SpikeTrain): return True - # Check for list or tuple - if isinstance(matrix, (list, tuple)): - return all(map(_check_neo_spiketrain, matrix)) + # Check for list, tuple, or SpikeTrainList + try: + return all(map(_check_neo_spiketrain, query)) + except TypeError: + pass + return False diff --git a/elephant/current_source_density.py b/elephant/current_source_density.py index 686c1fde9..6638d9e8e 100644 --- a/elephant/current_source_density.py +++ b/elephant/current_source_density.py @@ -62,7 +62,7 @@ @deprecated_alias(coords='coordinates') -def estimate_csd(lfp, coordinates=None, method=None, +def estimate_csd(lfp, coordinates='coordinates', method=None, process_estimate=True, **kwargs): """ Function call to compute the current source density (CSD) from @@ -72,12 +72,16 @@ def estimate_csd(lfp, coordinates=None, method=None, Parameters ---------- lfp : neo.AnalogSignal - positions of electrodes can be added as neo.RecordingChannel - coordinate or sent externally as a func argument (See coords) - coordinates : [Optional] corresponding spatial coordinates of the - electrodes. - Defaults to None - Otherwise looks for ChannelIndex coordinate + Positions of electrodes can be added as an array annotation + coordinates : array-like Quantity or string + Specifies the corresponding spatial coordinates of the electrodes. + Coordinates can be directly supplied by a NxM array-like Quantity + with dimension of space, where M is the number of signals in 'lfp', + and N is equal to the dimensionality of the method. + Alternatively, if coordinates is a string, the function will fetch the + coordinates, supplied in the same format, as annotation of 'lfp' by that + name. + Default: 'coordinates' method : string Pick a method corresponding to the setup, in this implementation For Laminar probe style (1D), use 'KCSD1D' or 'StandardCSD', @@ -114,17 +118,19 @@ def estimate_csd(lfp, coordinates=None, method=None, """ if not isinstance(lfp, neo.AnalogSignal): raise TypeError('Parameter `lfp` must be a neo.AnalogSignal object') - if coordinates is None: - coordinates = lfp.channel_index.coordinates - else: - scaled_coords = [] - for coord in coordinates: - try: - scaled_coords.append(coord.rescale(pq.mm)) - except AttributeError: - raise AttributeError('No units given for electrode spatial \ - coordinates') - coordinates = scaled_coords + if isinstance(coordinates, str): + coordinates = lfp.annotations[coordinates] + + # Scale all coordinates to mm as common basis + scaled_coords = [] + for coord in coordinates: + try: + scaled_coords.append(coord.rescale(pq.mm)) + except AttributeError: + raise AttributeError('No units given for electrode spatial \ + coordinates') + coordinates = scaled_coords + if method is None: raise ValueError('Must specify a method of CSD implementation') if len(coordinates) != lfp.shape[1]: @@ -249,7 +255,8 @@ def generate_lfp(csd_profile, x_positions, y_positions=None, z_positions=None, ------- LFP : neo.AnalogSignal The potentials created by the csd profile at the electrode positions. - The electrode positions are attached as RecordingChannel's coordinate. + The electrode positions are attached as an annotation named + 'coordinates'. """ def integrate_1D(x0, csd_x, csd, h): @@ -327,10 +334,8 @@ def integrate_3D(x, y, z, csd, xlin, ylin, zlin, X, Y, Z): pots /= 4 * np.pi * sigma ele_pos = np.vstack((x_positions, y_positions, z_positions)).T ele_pos = ele_pos * pq.mm - ch = neo.ChannelIndex(index=range(len(pots))) + asig = neo.AnalogSignal(np.expand_dims(pots, axis=0), sampling_rate=pq.kHz, units='mV') - ch.coordinates = ele_pos - ch.analogsignals.append(asig) - ch.create_relationship() + asig.annotate(coordinates=ele_pos) return asig diff --git a/elephant/spade.py b/elephant/spade.py index 34ecf51de..6f95e55cc 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -97,6 +97,7 @@ from itertools import chain, combinations import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from scipy import sparse @@ -614,7 +615,7 @@ def concepts_mining(spiketrains, bin_size, winlen, min_spikes=2, min_occ=2, "report has to assume of the following values:" + " 'a', '#' and '3d#,' got {} instead".format(report)) # if spiketrains is list of neo.SpikeTrain convert to conv.BinnedSpikeTrain - if isinstance(spiketrains, list) and \ + if isinstance(spiketrains, (list, SpikeTrainList)) and \ isinstance(spiketrains[0], neo.SpikeTrain): spiketrains = conv.BinnedSpikeTrain( spiketrains, bin_size=bin_size, tolerance=None) diff --git a/elephant/spike_train_synchrony.py b/elephant/spike_train_synchrony.py index c4f0ed505..8cde2d758 100644 --- a/elephant/spike_train_synchrony.py +++ b/elephant/spike_train_synchrony.py @@ -349,7 +349,11 @@ def delete_synchrofacts(self, threshold, in_place=False, mode='delete'): # replace link to spiketrain in segment new_index = self._get_spiketrain_index( segment.spiketrains, st) - segment.spiketrains[new_index] = new_st + # Todo: Simplify following lines once Neo SpikeTrainList + # implments indexed assignment of entries (i.e., stl[i]=st) + spiketrainlist = list(segment.spiketrains) + spiketrainlist[new_index] = new_st + segment.spiketrains = spiketrainlist except ValueError: # st is not in this segment even though it points to it warnings.warn(f"The SpikeTrain at index {idx} of the " diff --git a/elephant/statistics.py b/elephant/statistics.py index 170aad6c5..1fa076f5e 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -70,6 +70,7 @@ import warnings import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq import scipy.stats @@ -769,7 +770,7 @@ def optimal_kernel(st): if kernel == 'auto': kernel = optimal_kernel(spiketrains) spiketrains = [spiketrains] - elif not isinstance(spiketrains, (list, tuple)): + elif not isinstance(spiketrains, (list, tuple, SpikeTrainList)): raise TypeError( "'spiketrains' must be a list of neo.SpikeTrain's or a single " "neo.SpikeTrain. Found: '{}'".format(type(spiketrains))) diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index d0fde16b7..e63d6690d 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -9,6 +9,7 @@ import unittest import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from numpy.testing import (assert_array_almost_equal, assert_array_equal) @@ -185,6 +186,28 @@ def test_bin_edges_empty_binned_spiketrain(self): assert_array_equal(bst.spike_indices, [[]]) # no binned spikes self.assertEqual(bst.get_num_of_spikes(), 0) + def test_regression_431(self): + """ + Addresses issue 431 + This unittest addresses an issue where a SpikeTrainList obejct was not + correctly handled by the constructor + """ + st1 = neo.SpikeTrain( + times=np.array([1, 2, 3]) * pq.ms, + t_start=0 * pq.ms, t_stop=10 * pq.ms) + st2 = neo.SpikeTrain( + times=np.array([4, 5, 6]) * pq.ms, + t_start=0 * pq.ms, t_stop=10 * pq.ms) + real_list = [st1, st2] + spiketrainlist = SpikeTrainList([st1, st2]) + + real_list_binary = cv.BinnedSpikeTrain(real_list, bin_size=1*pq.ms) + spiketrainlist_binary = cv.BinnedSpikeTrain( + spiketrainlist, bin_size=1 * pq.ms) + + assert_array_equal( + real_list_binary.to_array(), spiketrainlist_binary.to_array()) + class BinnedSpikeTrainTestCase(unittest.TestCase): def setUp(self): diff --git a/elephant/test/test_kcsd.py b/elephant/test/test_kcsd.py index 6a8527f30..ee98b96c1 100644 --- a/elephant/test/test_kcsd.py +++ b/elephant/test/test_kcsd.py @@ -32,11 +32,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd1d_estimate(self, cv_params={}): self.test_params.update(cv_params) @@ -86,11 +82,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd2d_estimate(self, cv_params={}): self.test_params.update(cv_params) @@ -149,11 +141,7 @@ def setUp(self): temp_signals.append(self.pots[ii]) self.an_sigs = neo.AnalogSignal(np.array(temp_signals).T * pq.mV, sampling_rate=1000 * pq.Hz) - chidx = neo.ChannelIndex(range(len(self.pots))) - chidx.analogsignals.append(self.an_sigs) - chidx.coordinates = self.ele_pos * pq.mm - - chidx.create_relationship() + self.an_sigs.annotate(coordinates=self.ele_pos * pq.mm) def test_kcsd3d_estimate(self, cv_params={}): self.test_params.update(cv_params) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 299bc62b7..a85c1ed56 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -10,6 +10,7 @@ import random import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq from numpy.testing.utils import assert_array_equal @@ -180,6 +181,35 @@ def test_spade_msip(self): # check the lags assert_array_equal(lags_msip, self.lags_msip) + # Testing with multiple patterns input + def test_spade_msip_spiketrainlist(self): + output_msip = spade.spade( + SpikeTrainList(self.msip), self.bin_size, self.winlen, + approx_stab_pars=dict( + n_subsets=self.n_subset, + stability_thresh=self.stability_thresh), + n_surr=self.n_surr, alpha=self.alpha, + psr_param=self.psr_param, + stat_corr='no', + output_format='patterns')['patterns'] + elements_msip = [] + occ_msip = [] + lags_msip = [] + # collecting spade output + for out in output_msip: + elements_msip.append(out['neurons']) + occ_msip.append(list(out['times'].magnitude)) + lags_msip.append(list(out['lags'].magnitude)) + elements_msip = sorted(elements_msip, key=len) + occ_msip = sorted(occ_msip, key=len) + lags_msip = sorted(lags_msip, key=len) + # check neurons in the patterns + assert_array_equal(elements_msip, self.elements_msip) + # check the occurrences time of the patters + assert_array_equal(occ_msip, self.occ_msip) + # check the lags + assert_array_equal(lags_msip, self.lags_msip) + def test_parameters(self): """ Test under different configuration of parameters than the default one diff --git a/elephant/utils.py b/elephant/utils.py index 445b74bc3..3ce1e9206 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -16,6 +16,7 @@ from functools import wraps import neo +from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq @@ -188,7 +189,7 @@ def check_neo_consistency(neo_objects, object_type, t_start=None, ValueError If input object units, t_start, or t_stop do not match across trials. """ - if not isinstance(neo_objects, (list, tuple)): + if not isinstance(neo_objects, (list, tuple, SpikeTrainList)): neo_objects = [neo_objects] try: units = neo_objects[0].units diff --git a/requirements/requirements.txt b/requirements/requirements.txt index e89638ae3..25f8e040b 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,4 +1,4 @@ -neo>=0.9.0,<0.10.0 +neo>=0.10.0 numpy>=1.18.1 quantities>=0.12.1 scipy<1.7.0 From 854a5ca88c0cfec94416be847f57b35e8f5e07a8 Mon Sep 17 00:00:00 2001 From: Michael Denker Date: Mon, 14 Mar 2022 08:09:29 +0100 Subject: [PATCH 41/63] Fixes neo_tools unit tests to work with Neo 0.10.0+ (#446) * First fix for unittests missing fake_neo objects * Fixed all GetAllObjsTestCase unit tests * Started work on Events test case * Fixed Events test case * Fixed Epochs and Spiketrain tests * Starting to fix ExtractNeoAttrs * 7 more failing tests for ExtractNeoAttrs * All neo_tools tests fixed for Neo 0.10 * Enabled dataset generators from neo 0.10.0 * This PR adds SpikeTrainList as output of `get_all_spiketrains()`` * Use SpikeTrainList, work around SpikeTrainList.extend() bug. * Fix pandas_bridge tests to work without fake_neo() * PEP8 Line length corrections * More PEP8 finishes * Yet more PEP8 finishes * Last PEP8 finish * Update elephant/neo_tools.py --- elephant/neo_tools.py | 5 +- elephant/test/test_neo_tools.py | 905 +++++++++++++++++----------- elephant/test/test_pandas_bridge.py | 750 ++++++++++++++++------- 3 files changed, 1087 insertions(+), 573 deletions(-) diff --git a/elephant/neo_tools.py b/elephant/neo_tools.py index e2cd4da84..b0e11f9bb 100644 --- a/elephant/neo_tools.py +++ b/elephant/neo_tools.py @@ -19,6 +19,7 @@ from itertools import chain +from neo.core.spiketrainlist import SpikeTrainList from neo.core.container import unique_objs from elephant.utils import deprecated_alias @@ -180,10 +181,10 @@ def get_all_spiketrains(container): Returns ------- list - A list of the unique `neo.SpikeTrain` objects in `container`. + A `neo.SpikeTrainList` object of the unique `neo.SpikeTrain` objects in `container`. """ - return _get_all_objs(container, 'SpikeTrain') + return SpikeTrainList(_get_all_objs(container, 'SpikeTrain')) def get_all_events(container): diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index c61313758..b3e262f48 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -5,23 +5,32 @@ :copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ - +import random from itertools import chain +import copy import unittest -from neo.test.generate_datasets import fake_neo, get_fake_values +import neo.core +# TODO: In Neo 0.10.0, SpikeTrainList ist not exposed in __init__.py of +# neo.core. Remove the following line if SpikeTrainList is accessible via +# neo.core +from neo.core.spiketrainlist import SpikeTrainList + +from neo.test.generate_datasets import generate_one_simple_block, \ + generate_one_simple_segment, \ + random_event, random_epoch, random_spiketrain from neo.test.tools import assert_same_sub_schema + from numpy.testing.utils import assert_array_equal import elephant.neo_tools as nt - # A list of neo object attributes that contain arrays. ARRAY_ATTRS = ['waveforms', 'times', 'durations', 'labels', - 'index', + # 'index', 'channel_names', 'channel_ids', 'coordinates', @@ -69,6 +78,23 @@ def strip_iter_values(targ, array_attrs=ARRAY_ATTRS): class GetAllObjsTestCase(unittest.TestCase): + def setUp(self): + random.seed(4245) + self.spiketrain = random_spiketrain( + 'Single SpikeTrain', seed=random.random()) + self.spiketrain_list = [ + random_spiketrain('SpikeTrain', seed=random.random()), + random_spiketrain('SpikeTrain', seed=random.random())] + self.spiketrain_dict = { + 'a': random_spiketrain('SpikeTrain', seed=random.random()), + 123: random_spiketrain('SpikeTrain', seed=random.random())} + + self.epoch = random_epoch() + self.epoch_list = [ + random_epoch(), random_epoch()] + self.epoch_dict = { + 'a': random_epoch(), 123: random_epoch()} + def test__get_all_objs__float_valueerror(self): value = 5. with self.assertRaises(ValueError): @@ -80,7 +106,7 @@ def test__get_all_objs__list_float_valueerror(self): nt._get_all_objs(value, 'Block') def test__get_all_objs__epoch_for_event_valueerror(self): - value = fake_neo('Epoch', n=10, seed=0) + value = self.epoch with self.assertRaises(ValueError): nt._get_all_objs(value, 'Event') @@ -134,82 +160,67 @@ def test__get_all_objs__empty_nested_iter(self): def test__get_all_objs__empty_nested_many(self): targ = [] - value = iter([[], {'c': [], 'd':(iter([]),)}]) + value = iter([[], {'c': [], 'd': (iter([]),)}]) res = nt._get_all_objs(value, 'Block') self.assertEqual(targ, res) def test__get_all_objs__spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0)] - value = fake_neo('SpikeTrain', n=10, seed=0) + value = self.spiketrain + targ = [self.spiketrain] res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) def test__get_all_objs__list_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] + value = self.spiketrain_list + targ = self.spiketrain_list res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) def test__get_all_objs__nested_list_epoch(self): - targ = [fake_neo('Epoch', n=10, seed=0), - fake_neo('Epoch', n=10, seed=1)] - value = [[fake_neo('Epoch', n=10, seed=0)], - fake_neo('Epoch', n=10, seed=1)] + targ = self.epoch_list + value = [self.epoch_list] res = nt._get_all_objs(value, 'Epoch') assert_same_sub_schema(targ, res) def test__get_all_objs__iter_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = iter([fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)]) + targ = self.spiketrain_list + value = iter([self.spiketrain_list[0], + self.spiketrain_list[1]]) res = nt._get_all_objs(value, 'SpikeTrain') assert_same_sub_schema(targ, res) def test__get_all_objs__nested_iter_epoch(self): - targ = [fake_neo('Epoch', n=10, seed=0), - fake_neo('Epoch', n=10, seed=1)] - value = iter([iter([fake_neo('Epoch', n=10, seed=0)]), - fake_neo('Epoch', n=10, seed=1)]) + targ = self.epoch_list + value = iter([iter(self.epoch_list)]) res = nt._get_all_objs(value, 'Epoch') assert_same_sub_schema(targ, res) def test__get_all_objs__dict_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': fake_neo('SpikeTrain', n=10, seed=0), - 'b': fake_neo('SpikeTrain', n=10, seed=1)} + targ = [self.spiketrain_dict['a'], self.spiketrain_dict[123]] + value = self.spiketrain_dict res = nt._get_all_objs(value, 'SpikeTrain') self.assertEqual(len(targ), len(res)) - for i, itarg in enumerate(targ): - for ires in res: - if itarg.annotations['seed'] == ires.annotations['seed']: - assert_same_sub_schema(itarg, ires) - break - else: - raise ValueError('Target %s not in result' % i) + for t, r in zip(targ, res): + assert_same_sub_schema(t, r) def test__get_all_objs__nested_dict_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': fake_neo('SpikeTrain', n=10, seed=0), - 'b': {'c': fake_neo('SpikeTrain', n=10, seed=1)}} + targ = self.spiketrain_list + value = {'a': self.spiketrain_list[0], + 'b': {'c': self.spiketrain_list[1]}} res = nt._get_all_objs(value, 'SpikeTrain') @@ -223,10 +234,9 @@ def test__get_all_objs__nested_dict_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__nested_many_spiketrain(self): - targ = [fake_neo('SpikeTrain', n=10, seed=0), - fake_neo('SpikeTrain', n=10, seed=1)] - value = {'a': [fake_neo('SpikeTrain', n=10, seed=0)], - 'b': iter([fake_neo('SpikeTrain', n=10, seed=1)])} + targ = self.spiketrain_list + value = {'a': [self.spiketrain_list[0]], + 'b': iter([self.spiketrain_list[1]])} res = nt._get_all_objs(value, 'SpikeTrain') @@ -240,9 +250,10 @@ def test__get_all_objs__nested_many_spiketrain(self): raise ValueError('Target %s not in result' % i) def test__get_all_objs__unit_spiketrain(self): - value = fake_neo('Unit', n=3, seed=0) - targ = [fake_neo('SpikeTrain', n=3, seed=train.annotations['seed']) - for train in value.spiketrains] + value = neo.core.Group( + self.spiketrain_list, + name='Unit') + targ = self.spiketrain_list for train in value.spiketrains: train.annotations.pop('i', None) @@ -253,14 +264,8 @@ def test__get_all_objs__unit_spiketrain(self): assert_same_sub_schema(targ, res) def test__get_all_objs__block_epoch(self): - value = fake_neo('Block', n=3, seed=0) - targ = [fake_neo('Epoch', n=3, seed=train.annotations['seed']) - for train in value.list_children_by_class('Epoch')] - - for epoch in value.list_children_by_class('Epoch'): - epoch.annotations.pop('i', None) - epoch.annotations.pop('j', None) - + value = generate_one_simple_block('Block', n=3, seed=0) + targ = [train for train in value.list_children_by_class('Epoch')] res = nt._get_all_objs(value, 'Epoch') assert_same_sub_schema(targ, res) @@ -269,7 +274,12 @@ def test__get_all_objs__block_epoch(self): class ExtractNeoAttrsTestCase(unittest.TestCase): def setUp(self): self.maxDiff = None - self.block = fake_neo('Block', seed=0) + self.block = generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, + neo.core.Event, neo.core.Epoch]) def assert_dicts_equal(self, d1, d2): """Assert that two dictionaries are equal, taking into account arrays. @@ -311,8 +321,13 @@ def assert_dicts_equal(self, d1, d2): raise def test__extract_neo_attrs__spiketrain_noarray(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -334,9 +349,15 @@ def test__extract_neo_attrs__spiketrain_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) + for key, value in targ.copy().items(): if value is None: del targ[key] @@ -362,8 +383,12 @@ def test__extract_neo_attrs__spiketrain_noarray_skip_none(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__epoch_noarray(self): - obj = fake_neo('Epoch', seed=0) - targ = get_fake_values('Epoch', seed=0) + obj = random_epoch() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -385,8 +410,12 @@ def test__extract_neo_attrs__epoch_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__event_noarray(self): - obj = fake_neo('Event', seed=0) - targ = get_fake_values('Event', seed=0) + obj = random_event() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -408,8 +437,12 @@ def test__extract_neo_attrs__event_noarray(self): self.assertEqual(targ, res21) def test__extract_neo_attrs__spiketrain_parents_empty_array(self): - obj = fake_neo('SpikeTrain', seed=0) - targ = get_fake_values('SpikeTrain', seed=0) + obj = random_spiketrain() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -456,10 +489,13 @@ def _fix_neo_issue_749(obj, targ): return obj def test__extract_neo_attrs__epoch_parents_empty_array(self): - obj = fake_neo('Epoch', seed=0) - targ = get_fake_values('Epoch', seed=0) + obj = random_epoch() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -497,8 +533,12 @@ def test__extract_neo_attrs__epoch_parents_empty_array(self): self.assert_dicts_equal(targ, res211) def test__extract_neo_attrs__event_parents_empty_array(self): - obj = fake_neo('Event', seed=0) - targ = get_fake_values('Event', seed=0) + obj = random_event() + targ = copy.deepcopy(obj.annotations) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) del targ['times'] res000 = nt.extract_neo_attributes(obj, parents=False) @@ -537,7 +577,12 @@ def test__extract_neo_attrs__event_parents_empty_array(self): def test__extract_neo_attrs__spiketrain_noparents_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -546,20 +591,21 @@ def test__extract_neo_attrs__spiketrain_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) def test__extract_neo_attrs__epoch_noparents_noarray(self): obj = self.block.list_children_by_class('Epoch')[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -568,20 +614,19 @@ def test__extract_neo_attrs__epoch_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) def test__extract_neo_attrs__event_noparents_noarray(self): obj = self.block.list_children_by_class('Event')[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=False, skip_array=True) @@ -590,20 +635,21 @@ def test__extract_neo_attrs__event_noparents_noarray(self): res2 = nt.extract_neo_attributes(obj, parents=False, skip_array=True, child_first=False) - del res0['i'] - del res1['i'] - del res2['i'] - del res0['j'] - del res1['j'] - del res2['j'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) self.assertEqual(targ, res2) def test__extract_neo_attrs__spiketrain_noparents_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -616,19 +662,6 @@ def test__extract_neo_attrs__spiketrain_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -638,10 +671,15 @@ def test__extract_neo_attrs__spiketrain_noparents_array(self): def test__extract_neo_attrs__epoch_noparents_array(self): obj = self.block.list_children_by_class('Epoch')[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) # 'times' is not in obj._necessary_attrs + obj._recommended_attrs - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -654,19 +692,6 @@ def test__extract_neo_attrs__epoch_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -676,7 +701,15 @@ def test__extract_neo_attrs__epoch_noparents_array(self): def test__extract_neo_attrs__event_noparents_array(self): obj = self.block.list_children_by_class('Event')[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + # 'times' is not in obj._necessary_attrs + obj._recommended_attrs del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=False, skip_array=False) @@ -689,19 +722,6 @@ def test__extract_neo_attrs__event_noparents_array(self): res21 = nt.extract_neo_attributes( obj, parents=False, child_first=False) - del res00['i'] - del res10['i'] - del res20['i'] - del res01['i'] - del res11['i'] - del res21['i'] - del res00['j'] - del res10['j'] - del res20['j'] - del res01['j'] - del res11['j'] - del res21['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res20) @@ -713,30 +733,31 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - rcg = self.block.channel_indexes[0] - unit = self.block.channel_indexes[0].units[0] - - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('ChannelIndex', - seed=rcg.annotations['seed'])) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('SpikeTrain', - seed=obj.annotations['seed'])) + + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -745,23 +766,31 @@ def test__extract_neo_attrs__epoch_parents_childfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Epoch', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -770,23 +799,30 @@ def test__extract_neo_attrs__event_parents_childfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Event', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True) res1 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=True) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - del res1['index'] - self.assertEqual(targ, res0) self.assertEqual(targ, res1) @@ -794,25 +830,30 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_noarray(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - rcg = self.block.channel_indexes[0] - unit = self.block.channel_indexes[0].units[0] - - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('ChannelIndex', - seed=rcg.annotations['seed'])) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__epoch_parents_parentfirst_noarray(self): @@ -820,19 +861,30 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__event_parents_parentfirst_noarray(self): @@ -840,32 +892,56 @@ def test__extract_neo_attrs__event_parents_parentfirst_noarray(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + targ = strip_iter_values(targ) res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=True, child_first=False) - del res0['i'] - del res0['j'] - # name clash between Block.index and ChannelIndex.index - del res0['index'] - self.assertEqual(targ, res0) def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - unit = self.block.channel_indexes[0].units[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('SpikeTrain', - seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -874,12 +950,6 @@ def test__extract_neo_attrs__spiketrain_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - ignore_annotations = ('i', 'j', 'channel_names', - 'channel_ids', 'coordinates') - for res in (res00, res01, res10, res11): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -890,11 +960,25 @@ def test__extract_neo_attrs__epoch_parents_childfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Epoch', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -903,11 +987,6 @@ def test__extract_neo_attrs__epoch_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - ignore_annotations = ('i', 'j') - for res in (res00, res01, res10, res11): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -918,9 +997,25 @@ def test__extract_neo_attrs__event_parents_childfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Block', seed=blk.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Event', seed=obj.annotations['seed'])) + targ = copy.deepcopy(blk.annotations) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(obj.annotations)) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + del targ['times'] res00 = nt.extract_neo_attributes(obj, parents=True, skip_array=False) @@ -929,15 +1024,6 @@ def test__extract_neo_attrs__event_parents_childfirst_array(self): res01 = nt.extract_neo_attributes(obj, parents=True) res11 = nt.extract_neo_attributes(obj, parents=True, child_first=True) - del res00['i'] - del res10['i'] - del res01['i'] - del res11['i'] - del res00['j'] - del res10['j'] - del res01['j'] - del res11['j'] - self.assert_dicts_equal(targ, res00) self.assert_dicts_equal(targ, res10) self.assert_dicts_equal(targ, res01) @@ -947,25 +1033,32 @@ def test__extract_neo_attrs__spiketrain_parents_parentfirst_array(self): obj = self.block.list_children_by_class('SpikeTrain')[0] blk = self.block seg = self.block.segments[0] - unit = self.block.channel_indexes[0].units[0] - targ = get_fake_values('SpikeTrain', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Unit', seed=unit.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.SpikeTrain._necessary_attrs + + neo.SpikeTrain._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + del targ['times'] - del targ['index'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - ignore_annotations = ('i', 'j', 'index', 'channel_names', - 'channel_ids', 'coordinates') - for res in (res0, res1): - for attr in ignore_annotations: - del res[attr] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) @@ -974,22 +1067,31 @@ def test__extract_neo_attrs__epoch_parents_parentfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Epoch', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy(dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Epoch._necessary_attrs + + neo.Epoch._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) - obj = self._fix_neo_issue_749(obj, targ) del targ['times'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) @@ -998,27 +1100,39 @@ def test__extract_neo_attrs__event_parents_parentfirst_array(self): blk = self.block seg = self.block.segments[0] - targ = get_fake_values('Event', seed=obj.annotations['seed']) - targ.update(get_fake_values('Segment', seed=seg.annotations['seed'])) - targ.update(get_fake_values('Block', seed=blk.annotations['seed'])) + targ = copy.deepcopy(obj.annotations) + targ["array_annotations"] = copy.deepcopy( + dict(obj.array_annotations)) + for i, attr in enumerate( + neo.Event._necessary_attrs + + neo.Event._recommended_attrs): + targ[attr[0]] = getattr(obj, attr[0]) + + targ.update(copy.deepcopy(seg.annotations)) + for i, attr in enumerate( + neo.Segment._necessary_attrs + + neo.Segment._recommended_attrs): + targ[attr[0]] = getattr(seg, attr[0]) + + targ.update(copy.deepcopy(blk.annotations)) + for i, attr in enumerate( + neo.Block._necessary_attrs + + neo.Block._recommended_attrs): + targ[attr[0]] = getattr(blk, attr[0]) + del targ['times'] res0 = nt.extract_neo_attributes(obj, parents=True, skip_array=False, child_first=False) res1 = nt.extract_neo_attributes(obj, parents=True, child_first=False) - del res0['i'] - del res1['i'] - del res0['j'] - del res1['j'] - self.assert_dicts_equal(targ, res0) self.assert_dicts_equal(targ, res1) class GetAllSpiketrainsTestCase(unittest.TestCase): def test__get_all_spiketrains__spiketrain(self): - obj = fake_neo('SpikeTrain', seed=0, n=5) + obj = random_spiketrain() res0 = nt.get_all_spiketrains(obj) targ = obj @@ -1027,25 +1141,40 @@ def test__get_all_spiketrains__spiketrain(self): assert_same_sub_schema(targ, res0[0]) - def test__get_all_spiketrains__unit(self): - obj = fake_neo('Unit', seed=0, n=7) - obj.spiketrains.append(obj.spiketrains[0]) - res0 = nt.get_all_spiketrains(obj) - - targ = fake_neo('Unit', seed=0, n=7).spiketrains - - self.assertTrue(len(res0) > 0) - - self.assertEqual(len(targ), len(res0)) - - assert_same_sub_schema(targ, res0) + # Todo: Units are no longer supported, but is a test for + # neo.Group required instead? + # def test__get_all_spiketrains__unit(self): + # obj = generate_one_simple_block( + # nb_segment=3, + # supported_objects=[ + # neo.core.Block, neo.core.Segment, + # neo.core.SpikeTrain, neo.core.Group]) + # targ = copy.deepcopy(obj) + # + # obj.groups[0].spiketrains.append(obj.groups[0].spiketrains[0]) + # res0 = nt.get_all_spiketrains(obj) + # + # targ = targ.spiketrains + # + # self.assertTrue(len(res0) > 0) + # + # self.assertEqual(len(targ), len(res0)) + # + # assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__segment(self): - obj = fake_neo('Segment', seed=0, n=5) - obj.spiketrains.extend(obj.spiketrains) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.SpikeTrain]) + targ = copy.deepcopy(obj) + obj.spiketrains.append(obj.spiketrains[0]) + # TODO: The following is the original line of the test, however, this + # fails with Neo 0.10.0 + # Reinstate once issue is fixed + # obj.spiketrains.extend(obj.spiketrains) + res0 = nt.get_all_spiketrains(obj) - targ = fake_neo('Segment', seed=0, n=5).spiketrains + targ = targ.spiketrains self.assertTrue(len(res0) > 0) @@ -1054,15 +1183,19 @@ def test__get_all_spiketrains__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__block(self): - obj = fake_neo('Block', seed=0, n=3) - iobj1 = obj.channel_indexes[0].units[0] - obj.channel_indexes[0].units.append(iobj1) - iobj2 = obj.channel_indexes[0].units[2].spiketrains[1] - obj.channel_indexes[1].units[1].spiketrains.append(iobj2) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + targ = copy.deepcopy(obj) + + iobj1 = obj.segments[0] + obj.segments.append(iobj1) + iobj2 = obj.segments[0].spiketrains[1] + obj.segments[1].spiketrains.append(iobj2) res0 = nt.get_all_spiketrains(obj) - targ = fake_neo('Block', seed=0, n=3) - targ = targ.list_children_by_class('SpikeTrain') + targ = SpikeTrainList(targ.list_children_by_class('SpikeTrain')) self.assertTrue(len(res0) > 0) @@ -1071,18 +1204,22 @@ def test__get_all_spiketrains__block(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] - obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) res0 = nt.get_all_spiketrains(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1091,18 +1228,23 @@ def test__get_all_spiketrains__list(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] + targ = copy.deepcopy(obj) + obj.append(obj[-1]) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[0]) res0 = nt.get_all_spiketrains(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1111,18 +1253,23 @@ def test__get_all_spiketrains__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[1]) + res0 = nt.get_all_spiketrains(obj) res0 = nt.get_all_spiketrains(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1131,19 +1278,24 @@ def test__get_all_spiketrains__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_spiketrains__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.SpikeTrain]) + for _ in range(3)] + targ = copy.deepcopy(obj) + iobj1 = obj[2].segments[0] + obj[2].segments.append(iobj1) + iobj2 = obj[1].segments[2].spiketrains[1] + obj[2].segments[1].spiketrains.append(iobj2) obj.append(obj[-1]) - iobj1 = obj[2].channel_indexes[0].units[0] - obj[2].channel_indexes[0].units.append(iobj1) - iobj2 = obj[1].channel_indexes[1].units[2].spiketrains[1] - obj[2].channel_indexes[0].units[1].spiketrains.append(iobj2) - obj.append(obj[1]) + res0 = nt.get_all_spiketrains(obj) obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_spiketrains(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('SpikeTrain') for iobj in targ] - targ = list(chain.from_iterable(targ)) + targ = SpikeTrainList(list(chain.from_iterable(targ))) self.assertTrue(len(res0) > 0) @@ -1154,7 +1306,7 @@ def test__get_all_spiketrains__dict(self): class GetAllEventsTestCase(unittest.TestCase): def test__get_all_events__event(self): - obj = fake_neo('Event', seed=0, n=5) + obj = random_event() res0 = nt.get_all_events(obj) targ = obj @@ -1164,11 +1316,14 @@ def test__get_all_events__event(self): assert_same_sub_schema(targ, res0[0]) def test__get_all_events__segment(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.Event]) + targ = copy.deepcopy(obj) + obj.events.extend(obj.events) res0 = nt.get_all_events(obj) - targ = fake_neo('Segment', seed=0, n=5).events + targ = targ.events self.assertTrue(len(res0) > 0) @@ -1177,14 +1332,18 @@ def test__get_all_events__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_events__block(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + targ = copy.deepcopy(obj) + iobj1 = obj.segments[0] obj.segments.append(iobj1) iobj2 = obj.segments[0].events[1] obj.segments[1].events.append(iobj2) res0 = nt.get_all_events(obj) - targ = fake_neo('Block', seed=0, n=3) targ = targ.list_children_by_class('Event') self.assertTrue(len(res0) > 0) @@ -1194,7 +1353,13 @@ def test__get_all_events__block(self): assert_same_sub_schema(targ, res0) def test__get_all_events__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1203,7 +1368,6 @@ def test__get_all_events__list(self): obj.append(obj[-1]) res0 = nt.get_all_events(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1214,7 +1378,13 @@ def test__get_all_events__list(self): assert_same_sub_schema(targ, res0) def test__get_all_events__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1223,7 +1393,6 @@ def test__get_all_events__tuple(self): obj.append(obj[0]) res0 = nt.get_all_events(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1234,7 +1403,13 @@ def test__get_all_events__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_events__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1243,7 +1418,6 @@ def test__get_all_events__iter(self): obj.append(obj[0]) res0 = nt.get_all_events(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1254,7 +1428,13 @@ def test__get_all_events__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_events__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Event]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1264,7 +1444,6 @@ def test__get_all_events__dict(self): obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_events(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Event') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1277,7 +1456,7 @@ def test__get_all_events__dict(self): class GetAllEpochsTestCase(unittest.TestCase): def test__get_all_epochs__epoch(self): - obj = fake_neo('Epoch', seed=0, n=5) + obj = random_epoch() res0 = nt.get_all_epochs(obj) targ = obj @@ -1287,11 +1466,13 @@ def test__get_all_epochs__epoch(self): assert_same_sub_schema(targ, res0[0]) def test__get_all_epochs__segment(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[neo.core.Segment, neo.core.Epoch]) + targ = copy.deepcopy(obj) obj.epochs.extend(obj.epochs) res0 = nt.get_all_epochs(obj) - targ = fake_neo('Segment', seed=0, n=5).epochs + targ = targ.epochs self.assertTrue(len(res0) > 0) @@ -1300,14 +1481,18 @@ def test__get_all_epochs__segment(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__block(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + targ = copy.deepcopy(obj) + iobj1 = obj.segments[0] obj.segments.append(iobj1) iobj2 = obj.segments[0].epochs[1] obj.segments[1].epochs.append(iobj2) res0 = nt.get_all_epochs(obj) - targ = fake_neo('Block', seed=0, n=3) targ = targ.list_children_by_class('Epoch') self.assertTrue(len(res0) > 0) @@ -1317,7 +1502,13 @@ def test__get_all_epochs__block(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__list(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1326,7 +1517,6 @@ def test__get_all_epochs__list(self): obj.append(obj[-1]) res0 = nt.get_all_epochs(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1337,7 +1527,13 @@ def test__get_all_epochs__list(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__tuple(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1346,7 +1542,6 @@ def test__get_all_epochs__tuple(self): obj.append(obj[0]) res0 = nt.get_all_epochs(tuple(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1357,7 +1552,13 @@ def test__get_all_epochs__tuple(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__iter(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1366,7 +1567,6 @@ def test__get_all_epochs__iter(self): obj.append(obj[0]) res0 = nt.get_all_epochs(iter(obj)) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) @@ -1377,7 +1577,13 @@ def test__get_all_epochs__iter(self): assert_same_sub_schema(targ, res0) def test__get_all_epochs__dict(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=3, + supported_objects=[ + neo.core.Block, neo.core.Segment, neo.core.Epoch]) + for _ in range(3)] + targ = copy.deepcopy(obj) obj.append(obj[-1]) iobj1 = obj[2].segments[0] obj[2].segments.append(iobj1) @@ -1387,7 +1593,6 @@ def test__get_all_epochs__dict(self): obj = dict((i, iobj) for i, iobj in enumerate(obj)) res0 = nt.get_all_epochs(obj) - targ = [fake_neo('Block', seed=i, n=3) for i in range(3)] targ = [iobj.list_children_by_class('Epoch') for iobj in targ] targ = list(chain.from_iterable(targ)) diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 5a94b4a3b..78cd71635 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -13,7 +13,10 @@ import numpy as np import quantities as pq -from neo.test.generate_datasets import fake_neo +import neo.core +from neo.test.generate_datasets import generate_one_simple_block, \ + generate_one_simple_segment, \ + random_event, random_epoch, random_spiketrain from numpy.testing import assert_array_equal try: @@ -167,7 +170,7 @@ def test__convert_value_safe__quantity_scalar(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class SpiketrainToDataframeTestCase(unittest.TestCase): def test__spiketrain_to_dataframe__parents_empty(self): - obj = fake_neo('SpikeTrain', seed=0) + obj = random_spiketrain() res0 = ep.spiketrain_to_dataframe(obj) res1 = ep.spiketrain_to_dataframe(obj, child_first=True) @@ -270,7 +273,14 @@ def test__spiketrain_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj, parents=False) @@ -320,7 +330,14 @@ def test__spiketrain_to_dataframe__noparents(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj) res1 = ep.spiketrain_to_dataframe(obj, child_first=True) @@ -375,7 +392,14 @@ def test__spiketrain_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__spiketrain_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=0) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) obj = blk.list_children_by_class('SpikeTrain')[0] res0 = ep.spiketrain_to_dataframe(obj, child_first=False) res1 = ep.spiketrain_to_dataframe(obj, parents=True, child_first=False) @@ -415,7 +439,7 @@ def test__spiketrain_to_dataframe__parents_parentfirst(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class EventToDataframeTestCase(unittest.TestCase): def test__event_to_dataframe__parents_empty(self): - obj = fake_neo('Event', seed=42) + obj = random_event() res0 = ep.event_to_dataframe(obj) res1 = ep.event_to_dataframe(obj, child_first=True) @@ -523,7 +547,14 @@ def test__event_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__event_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj, parents=False) @@ -573,7 +604,14 @@ def test__event_to_dataframe__noparents(self): assert_index_equal(value, level) def test__event_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj) @@ -632,7 +670,14 @@ def test__event_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__event_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Event'): + objs.annotate(test=5) obj = blk.list_children_by_class('Event')[0] res0 = ep.event_to_dataframe(obj, child_first=False) res1 = ep.event_to_dataframe(obj, parents=True, child_first=False) @@ -674,7 +719,7 @@ def test__event_to_dataframe__parents_parentfirst(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class EpochToDataframeTestCase(unittest.TestCase): def test__epoch_to_dataframe__parents_empty(self): - obj = fake_neo('Epoch', seed=42) + obj = random_epoch() res0 = ep.epoch_to_dataframe(obj) res1 = ep.epoch_to_dataframe(obj, child_first=True) @@ -806,7 +851,14 @@ def test__epoch_to_dataframe__parents_empty(self): assert_index_equal(value, level) def test__epoch_to_dataframe__noparents(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj, parents=False) @@ -867,7 +919,14 @@ def test__epoch_to_dataframe__noparents(self): assert_index_equal(value, level) def test__epoch_to_dataframe__parents_childfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj) @@ -939,7 +998,14 @@ def test__epoch_to_dataframe__parents_childfirst(self): assert_index_equal(value, level) def test__epoch_to_dataframe__parents_parentfirst(self): - blk = fake_neo('Block', seed=42) + blk = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in blk.list_children_by_class('Epoch'): + objs.annotate(test=5) obj = blk.list_children_by_class('Epoch')[0] res0 = ep.epoch_to_dataframe(obj, child_first=False) @@ -995,7 +1061,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_spiketrains_to_dataframe__single(self): - obj = fake_neo('SpikeTrain', seed=0, n=5) + obj = random_spiketrain() res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False) @@ -1074,40 +1140,14 @@ def test__multi_spiketrains_to_dataframe__single(self): assert_frame_equal(targ, res7) assert_frame_equal(targ, res8) - def test__multi_spiketrains_to_dataframe__unit_default(self): - obj = fake_neo('Unit', seed=0, n=5) - - res0 = ep.multi_spiketrains_to_dataframe(obj) - - objs = obj.spiketrains - - targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs] - targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1) - - keys = ep._extract_neo_attrs_safe(objs[0], parents=True, - child_first=True).keys() - keys = list(keys) - - targwidth = len(objs) - targlen = max(len(iobj) for iobj in objs) - - self.assertGreater(len(objs), 0) - - self.assertEqual(targwidth, len(targ.columns)) - self.assertEqual(targwidth, len(res0.columns)) - - self.assertEqual(targlen, len(targ.index)) - self.assertEqual(targlen, len(res0.index)) - - self.assertCountEqual(keys, targ.columns.names) - self.assertCountEqual(keys, res0.columns.names) - - assert_array_equal(targ.values, res0.values) - - assert_frame_equal(targ, res0) - def test__multi_spiketrains_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1138,7 +1178,14 @@ def test__multi_spiketrains_to_dataframe__segment_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False, @@ -1186,7 +1233,14 @@ def test__multi_spiketrains_to_dataframe__block_noparents(self): assert_frame_equal(targ, res2) def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True) @@ -1239,7 +1293,14 @@ def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('SpikeTrain'): + objs.annotate(test1=5) res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True, @@ -1280,7 +1341,17 @@ def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False, @@ -1329,7 +1400,17 @@ def test__multi_spiketrains_to_dataframe__list_noparents(self): assert_frame_equal(targ, res2) def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True) @@ -1383,7 +1464,17 @@ def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False) res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True, @@ -1425,7 +1516,17 @@ def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self): assert_frame_equal(targ, res1) def test__multi_spiketrains_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1458,7 +1559,17 @@ def test__multi_spiketrains_to_dataframe__tuple_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(iter(obj)) @@ -1490,7 +1601,19 @@ def test__multi_spiketrains_to_dataframe__iter_default(self): assert_frame_equal(targ, res0) def test__multi_spiketrains_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('SpikeTrain'): + objs.annotate(test=5) res0 = ep.multi_spiketrains_to_dataframe(obj) @@ -1530,7 +1653,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_events_to_dataframe__single(self): - obj = fake_neo('Event', seed=0, n=5) + obj = random_event() res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=False) @@ -1609,7 +1732,13 @@ def test__multi_events_to_dataframe__single(self): assert_frame_equal(targ, res8) def test__multi_events_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj) @@ -1638,14 +1767,21 @@ def test__multi_events_to_dataframe__segment_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj, parents=False) res1 = ep.multi_events_to_dataframe(obj, parents=False, @@ -1685,22 +1821,29 @@ def test__multi_events_to_dataframe__block_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_events_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=True) @@ -1743,18 +1886,18 @@ def test__multi_events_to_dataframe__block_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -1762,7 +1905,14 @@ def test__multi_events_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_events_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Event'): + objs.annotate(test1=5) res0 = ep.multi_events_to_dataframe(obj, child_first=False) res1 = ep.multi_events_to_dataframe(obj, parents=True, @@ -1797,18 +1947,28 @@ def test__multi_events_to_dataframe__block_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj, parents=False) res1 = ep.multi_events_to_dataframe(obj, parents=False, @@ -1849,22 +2009,32 @@ def test__multi_events_to_dataframe__list_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_events_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) res1 = ep.multi_events_to_dataframe(obj, parents=True) @@ -1908,18 +2078,18 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -1927,7 +2097,17 @@ def test__multi_events_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_events_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj, child_first=False) res1 = ep.multi_events_to_dataframe(obj, parents=True, @@ -1963,18 +2143,28 @@ def test__multi_events_to_dataframe__list_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_events_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = tuple([ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)]) + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) @@ -2004,14 +2194,24 @@ def test__multi_events_to_dataframe__tuple_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(iter(obj)) @@ -2040,14 +2240,26 @@ def test__multi_events_to_dataframe__iter_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_events_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('Event'): + objs.annotate(test=5) res0 = ep.multi_events_to_dataframe(obj) @@ -2077,9 +2289,9 @@ def test__multi_events_to_dataframe__dict_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) @@ -2091,7 +2303,7 @@ def setUp(self): self.assertCountEqual = self.assertItemsEqual def test__multi_epochs_to_dataframe__single(self): - obj = fake_neo('Epoch', seed=0, n=5) + obj = random_epoch() res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=False) @@ -2170,7 +2382,13 @@ def test__multi_epochs_to_dataframe__single(self): assert_frame_equal(targ, res8) def test__multi_epochs_to_dataframe__segment_default(self): - obj = fake_neo('Segment', seed=0, n=5) + obj = generate_one_simple_segment( + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test1=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2185,7 +2403,7 @@ def test__multi_epochs_to_dataframe__segment_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2198,14 +2416,21 @@ def test__multi_epochs_to_dataframe__segment_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__block_noparents(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=2, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test1=5) res0 = ep.multi_epochs_to_dataframe(obj, parents=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=False, @@ -2226,7 +2451,7 @@ def test__multi_epochs_to_dataframe__block_noparents(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2245,22 +2470,29 @@ def test__multi_epochs_to_dataframe__block_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_epochs_to_dataframe__block_parents_childfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=True) @@ -2281,7 +2513,7 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2303,18 +2535,18 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -2322,7 +2554,14 @@ def test__multi_epochs_to_dataframe__block_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): - obj = fake_neo('Block', seed=0, n=3) + obj = generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for objs in obj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, child_first=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=True, @@ -2341,7 +2580,7 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2357,18 +2596,28 @@ def test__multi_epochs_to_dataframe__block_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__list_noparents(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, parents=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=False, @@ -2390,7 +2639,7 @@ def test__multi_epochs_to_dataframe__list_noparents(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2409,22 +2658,32 @@ def test__multi_epochs_to_dataframe__list_noparents(self): self.assertCountEqual(keys, res1.columns.names) self.assertCountEqual(keys, res2.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) assert_frame_equal(targ, res2) def test__multi_epochs_to_dataframe__list_parents_childfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) res1 = ep.multi_epochs_to_dataframe(obj, parents=True) @@ -2446,7 +2705,7 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2468,18 +2727,18 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): self.assertCountEqual(keys, res2.columns.names) self.assertCountEqual(keys, res3.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res2.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res3.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res2.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res3.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) @@ -2487,7 +2746,17 @@ def test__multi_epochs_to_dataframe__list_parents_childfirst(self): assert_frame_equal(targ, res3) def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj, child_first=False) res1 = ep.multi_epochs_to_dataframe(obj, parents=True, @@ -2507,7 +2776,7 @@ def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2523,18 +2792,28 @@ def test__multi_epochs_to_dataframe__list_parents_parentfirst(self): self.assertCountEqual(keys, res0.columns.names) self.assertCountEqual(keys, res1.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res1.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res1.values, dtype=np.float)) assert_frame_equal(targ, res0) assert_frame_equal(targ, res1) def test__multi_epochs_to_dataframe__tuple_default(self): - obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3)) + obj = tuple([ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)]) + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2551,7 +2830,7 @@ def test__multi_epochs_to_dataframe__tuple_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2564,14 +2843,24 @@ def test__multi_epochs_to_dataframe__tuple_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__iter_default(self): - obj = [fake_neo('Block', seed=i, n=3) for i in range(3)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(3)] + for iobj in obj: + for objs in iobj.list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(iter(obj)) @@ -2587,7 +2876,7 @@ def test__multi_epochs_to_dataframe__iter_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2600,14 +2889,26 @@ def test__multi_epochs_to_dataframe__iter_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) def test__multi_epochs_to_dataframe__dict_default(self): - obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3)) + obj = dict( + ( + i, + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event])) + for i in range(3)) + for iobj in obj: + for objs in obj[iobj].list_children_by_class('Epoch'): + objs.annotate(test=5) res0 = ep.multi_epochs_to_dataframe(obj) @@ -2624,7 +2925,7 @@ def test__multi_epochs_to_dataframe__dict_default(self): targwidth = len(objs) targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations), len(iobj.labels))] for iobj in objs] - targlen = len(np.unique(np.hstack(targlen))) + targlen = len(np.hstack(targlen)) self.assertGreater(len(objs), 0) @@ -2637,9 +2938,9 @@ def test__multi_epochs_to_dataframe__dict_default(self): self.assertCountEqual(keys, targ.columns.names) self.assertCountEqual(keys, res0.columns.names) - assert_array_equal( - np.array(targ.values, dtype=np.float), - np.array(res0.values, dtype=np.float)) + # assert_array_equal( + # np.array(targ.values, dtype=np.float), + # np.array(res0.values, dtype=np.float)) assert_frame_equal(targ, res0) @@ -2647,7 +2948,14 @@ def test__multi_epochs_to_dataframe__dict_default(self): @unittest.skipUnless(HAVE_PANDAS, 'requires pandas') class SliceSpiketrainTestCase(unittest.TestCase): def setUp(self): - obj = [fake_neo('SpikeTrain', seed=i, n=3) for i in range(10)] + obj = [ + generate_one_simple_block( + nb_segment=1, + supported_objects=[ + neo.core.Block, neo.core.Segment, + neo.core.SpikeTrain, neo.core.AnalogSignal, + neo.core.Epoch, neo.core.Event]) + for _ in range(10)] self.obj = ep.multi_spiketrains_to_dataframe(obj) def test_single_none(self): From 67dd3f3ef86161c0e70faf6e50690bdfd591978c Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Mon, 14 Mar 2022 09:52:14 +0100 Subject: [PATCH 42/63] Feature: CI with GitHub actions (#451) * added CI.yml containing workflows * added badge for CI tests to README.md * restructured requirements, environment.yml refactored to environment-docs.yml and environment-tests.yml. * adapted runners according to new new .yml files * update requirements in environment-*.yml to neo>=0.10.0 --- .github/workflows/CI.yml | 316 +++++++++++++++++++++++++++++ README.md | 5 +- readthedocs.yml | 4 +- requirements/environment-docs.yml | 19 ++ requirements/environment-tests.yml | 19 ++ requirements/environment.yml | 2 +- 6 files changed, 359 insertions(+), 6 deletions(-) create mode 100644 .github/workflows/CI.yml create mode 100644 requirements/environment-docs.yml create mode 100644 requirements/environment-tests.yml diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 000000000..de04a89c1 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,316 @@ +# This workflow will setup GitHub-hosted runners and install the required dependencies for elephant tests. +# On a pull requests and on pushes to master it will run different tests for elephant. + +name: tests +# define events that trigger workflow 'tests' +on: + workflow_dispatch: # enables manual triggering of workflow + inputs: + logLevel: + description: 'Log level' + required: true + default: 'warning' + type: choice + options: + - info + - warning + - debug + pull_request: + branches: + - master + types: + #- assigned + #- unassigned + - labeled + #- unlabeled + - opened + #- edited + #- closed + #- reopened + #- synchronize + #- converted_to_draft + #- ready_for_review + #- locked + #- unlocked + #- review_requested + #- review_request_removed + #- auto_merge_enabled + #- auto_merge_disabled + +# jobs define the steps that will be executed on the runner +jobs: + # install dependencies and elephant with pip and run tests with pytest + build-and-test-pip: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.6, 3.7, 3.8, 3.9] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + # used to reset cache every month + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + - uses: actions/checkout@v2 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache test_env + uses: actions/cache@v2 + with: + path: ~/test_env + # Look to see if there is a cache hit for the corresponding requirements files + # cache will be reset on changes to any requirements or every month + key: ${{ runner.os }}-venv-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + # create an environment and install everything + python -m venv ~/test_env + source ~/test_env/bin/activate + + python -m pip install --upgrade pip + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: Build + run: | + source ~/test_env/bin/activate + python setup.py install + + - name: List packages + run: | + source ~/test_env/bin/activate + pip list + python --version + + - name: Test with pytest + run: | + source ~/test_env/bin/activate + pytest --cov=elephant + + # install dependencies with conda and run tests with pytest + test-conda: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - uses: actions/checkout@v2 + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + key: ${{ runner.os }}-pip-${{hashFiles('requirements/environment-tests.yml') }}-${{ steps.date.outputs.date }} + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + + - name: Install dependencies + run: | + conda update conda + conda env update --file requirements/environment-tests.yml --name base + + activate base + conda install -c conda-forge openmpi + pip install -r requirements/requirements-tests.txt + pip install pytest==6.2.5 # hotfix for pytest 7.0.0, remove once fixed + pip install pytest-cov coveralls + pip install . + + - name: List packages + run: | + activate base + pip list + conda list + python --version + + - name: Test with pytest + run: | + activate base + pytest --cov=elephant --import-mode=importlib + + # install dependencies with pip and run tests with pytest + test-pip: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.8,] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [windows-latest] + include: + # - os: ubuntu-latest + # path: ~/.cache/pip + # - os: macos-latest + # path: ~/Library/Caches/pip + - os: windows-latest + path: ~\AppData\Local\pip\Cache + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ${{ matrix.path }} + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: List packages + run: | + pip list + python --version + + - name: Test with pytest + run: | + python --version + pytest --cov=elephant + + # install dependencies and elephant with pip and run MPI + test-pip-MPI: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.6] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + - uses: actions/checkout@v2 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache test_env + uses: actions/cache@v2 + with: + path: ~/.cache/pip + # Look to see if there is a cache hit for the corresponding requirements files + # cache will be reset on changes to any requirements or every month + key: ${{ runner.os }}-venv-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Setup enviroment + run: | + sudo apt install -y libopenmpi-dev openmpi-bin + + python -m pip install --upgrade pip + pip install mpi4py + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: List packages + run: | + pip list + python --version + + - name: Test with pytest + run: | + mpiexec -n 1 python -m mpi4py -m pytest --cov=elephant + + # install dependencies for the documentation and build .html + docs: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + steps: + + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + sudo apt install -y libopenmpi-dev openmpi-bin + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ hashFiles('**/environment-docs.yml') }}-${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + sudo apt install -y libopenmpi-dev openmpi-bin + python -m pip install --upgrade pip + pip install -r requirements/requirements-docs.txt + pip install -r requirements/requirements-tutorials.txt + conda update conda + conda env update --file requirements/environment-docs.yml --name base + conda install -c conda-forge openmpi + conda install -c conda-forge pandoc + # run notebooks + sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py + + - name: List packages + run: | + pip list + conda list + python --version + + - name: make html + run: | + cd doc + make html \ No newline at end of file diff --git a/README.md b/README.md index 0f4d28432..b7a9971e1 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ [![Statistics](https://img.shields.io/pypi/dm/elephant)](https://seladb.github.io/StarTrack-js/#/preload?r=neuralensemble,elephant) [![Gitter](https://badges.gitter.im/python-elephant/community.svg)](https://gitter.im/python-elephant/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) [![DOI Latest Release](https://zenodo.org/badge/10311278.svg)](https://zenodo.org/badge/latestdoi/10311278) - +[![tests](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml/badge.svg)](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml) *Elephant* package analyses all sorts of neurophysiological data: spike trains, LFP, analog signals. The input-output data format is either @@ -44,5 +44,4 @@ See [acknowledgments](doc/acknowledgments.rst). #### Citation -See [citations](doc/citation.rst). - +See [citations](doc/citation.rst). \ No newline at end of file diff --git a/readthedocs.yml b/readthedocs.yml index 15fa6002f..5d6f4b6cd 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -9,7 +9,7 @@ sphinx: configuration: doc/conf.py conda: - environment: requirements/environment.yml + environment: requirements/environment-docs.yml python: install: @@ -18,4 +18,4 @@ python: extra_requirements: - docs - extras - - tutorials + - tutorials \ No newline at end of file diff --git a/requirements/environment-docs.yml b/requirements/environment-docs.yml new file mode 100644 index 000000000..c9da5d22c --- /dev/null +++ b/requirements/environment-docs.yml @@ -0,0 +1,19 @@ +name: elephant + +channels: + - conda-forge # required for MPI + +dependencies: + - python>=3.6 + - mpi4py + - numpy + - scipy + - tqdm + - pandas + - scikit-learn + - statsmodels + - jinja2 + - pip: + - neo>=0.10.0 + - viziphant + # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml new file mode 100644 index 000000000..c9da5d22c --- /dev/null +++ b/requirements/environment-tests.yml @@ -0,0 +1,19 @@ +name: elephant + +channels: + - conda-forge # required for MPI + +dependencies: + - python>=3.6 + - mpi4py + - numpy + - scipy + - tqdm + - pandas + - scikit-learn + - statsmodels + - jinja2 + - pip: + - neo>=0.10.0 + - viziphant + # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt diff --git a/requirements/environment.yml b/requirements/environment.yml index 68fdfe1a0..c9da5d22c 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -14,6 +14,6 @@ dependencies: - statsmodels - jinja2 - pip: - - neo>=0.9.0,<0.10.0 + - neo>=0.10.0 - viziphant # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt From 91c0b1fc6699180ff04afbc1890e10126f05861a Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 25 Mar 2022 16:17:03 +0100 Subject: [PATCH 43/63] Enh/add zenodo json (#459) * initial draft for .zenodo.json, collected some authors for release 0.11.0 from commits since release 0.10.0 * added keywords * changed license id * corrected creator entry * added authors * corrected entry * added entry * Apply suggestions from code review added keyword, corrected affiliation for INM Co-authored-by: Michael Denker * corrected INM affiliation in authors.rst and for all entries in .zenodo.json * added grants by id * added grant agreement no. 604102 (Human Brain Project, HBP) to .zenodo.json and acknowledgments.rst. * added "title" field * added orcid Pa. Da. * reformat Co-authored-by: Michael Denker --- .zenodo.json | 106 ++++++++++++++++++++++++++++++++++++++++ doc/acknowledgments.rst | 7 ++- doc/authors.rst | 2 +- 3 files changed, 113 insertions(+), 2 deletions(-) create mode 100644 .zenodo.json diff --git a/.zenodo.json b/.zenodo.json new file mode 100644 index 000000000..240195b29 --- /dev/null +++ b/.zenodo.json @@ -0,0 +1,106 @@ +{ + "creators": [ + { + "orcid": "0000-0003-1255-7300", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Denker, Michael" + }, + { + "orcid": "0000-0003-0503-5264", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Köhler, Cristiano" + }, + { + "orcid": "0000-0002-2403-928X", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Morales-Gregorio, Aitor" + }, + { + "orcid": "0000-0003-3776-4226", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Kleinjohann, Alexander" + }, + { + "orcid": "0000-0003-2498-0536", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Bouss, Peter" + }, + { + "orcid": "0000-0002-3818-5587", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Stella, Alessandra" + }, + { + "orcid": "0000-0003-0789-6279", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Jurkus, Regimantas" + }, + { + "orcid": "0000-0002-9302-5893", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Kramer, Maximilian" + }, + { + "orcid": "0000-0002-5555-3206", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Dąbrowska, Paulina" + }, + { + "orcid": "0000-0001-7292-1982", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Kern, Moritz" + }, + { + "orcid": "0000-0002-9557-1003", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Kurth, Anno Christopher" + }, + { + "orcid": "0000-0001-7373-5962", + "affiliation": "Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany", + "name": "Gutzen, Robin" + }, + { + "orcid": "0000-0003-2401-7862", + "affiliation": "Cognitronics and Sensor Systems, CITEC, Bielefeld University, Bielefeld, Germany", + "name": "Porrmann, Florian" + }, + { + "orcid": "0000-0002-3168-7365", + "affiliation": "Cognitronics and Sensor Systems, CITEC, Bielefeld University, Bielefeld, Germany", + "name": "Pilz, Sarah" + } + ], + + "title": "Elephant 0.11.0", + + "keywords": [ + "neuroscience", + "neurophysiology", + "electrophysiology", + "statistics", + "data-analysis" + ], + + "license": { + "id": "BSD-3-Clause" + }, + + "related_identifiers": [ + { + "scheme": "doi", + "identifier": "10.12751/incf.ni2018.0019", + "relation": "isDocumentedBy", + "resource_type": "publication-article" + } + ], + + "grants": [ + {"id": "604102"}, + {"id": "720270"}, + {"id": "785907"}, + {"id": "945539"} + ], + + "upload_type": "software" +} diff --git a/doc/acknowledgments.rst b/doc/acknowledgments.rst index 8e0b21407..c3cc2715e 100644 --- a/doc/acknowledgments.rst +++ b/doc/acknowledgments.rst @@ -2,4 +2,9 @@ Acknowledgments *************** -This open source software code was developed in part or in whole in the Human Brain Project, funded from the European Union’s Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and SGA3). +This open source software code was developed in part or in whole in the Human +Brain Project, funded from the European Union’s Horizon 2020 Framework +Programme for Research and Innovation under Specific Grant Agreements +No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and +SGA3) and European Union 7th Framework Programme (FP7/2007-2013) under grant +agreement no. 604102 (Human Brain Project, HBP). diff --git a/doc/authors.rst b/doc/authors.rst index d36ec722b..79e156ef3 100644 --- a/doc/authors.rst +++ b/doc/authors.rst @@ -50,7 +50,7 @@ contribution, and may not be the current affiliation of a contributor. * Florian Porrmann [13] * Sarah Pilz [13] -1. Institute of Neuroscience and Medicine (INM-6), Computational and Systems Neuroscience & Institute for Advanced Simulation (IAS-6), Theoretical Neuroscience, Jülich Research Centre and JARA, Jülich, Germany +1. Institute of Neuroscience and Medicine (INM-6) and Institute for Advanced Simulation (IAS-6) and JARA-Institute Brain Structure-Function Relationships (INM-10), Jülich Research Centre, Jülich, Germany 2. Unité de Neurosciences, Information et Complexité, CNRS UPR 3293, Gif-sur-Yvette, France 3. Electronic Visions Group, Kirchhoff-Institute for Physics, University of Heidelberg, Germany 4. Brain-Mind Institute, Ecole Polytechnique Fédérale de Lausanne, Switzerland From 392933a8ce8fbf271a49ea398b7aaf407a4edcd6 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 25 Mar 2022 16:18:19 +0100 Subject: [PATCH 44/63] Enh/add dois to documentation (#456) * added Zenodo DOIs to docs, "how to cite elephant" * added links for DOIs * fix: added spade notebook to toctree * added description for DOIs * deleted extended description of different DOIs * added "doi:" to DOI links * typos * reformulate citation, fixed typo --- doc/citation.rst | 23 ++++++++++++++++++----- doc/tutorials.rst | 1 + 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/doc/citation.rst b/doc/citation.rst index 503eaba66..62896cdca 100644 --- a/doc/citation.rst +++ b/doc/citation.rst @@ -1,16 +1,29 @@ *************** Citing Elephant *************** - To refer to the Elephant software package in publications, please use: -**Elephant (RRID:SCR_003833)**. - +Elephant (`doi:10.5281/zenodo.1186602 `_; +`RRID:SCR_003833 `_) + +To cite a specific version of Elephant use: + +* v0.10.0 `doi:10.5281/zenodo.4582366 `_ +* v0.9.0 `doi:10.5281/zenodo.4271489 `_ +* v0.8.0 `doi:10.5281/zenodo.3975676 `_ +* v0.7.0 `doi:10.5281/zenodo.3695277 `_ +* v0.6.4 `doi:10.5281/zenodo.3524331 `_ +* v0.6.3 `doi:10.5281/zenodo.3346596 `_ +* v0.6.1 `doi:10.5281/zenodo.2620229 `_ +* v0.5.0 `doi:10.5281/zenodo.1216145 `_ +* v0.4.3 `doi:10.5281/zenodo.1187084 `_ +* v0.4.2 `doi:10.5281/zenodo.1186603 `_ + To cite Elephant, please use: **Denker M, Yegenoglu A, Grün S (2018) Collaborative HPC-enabled workflows on the HBP Collaboratory using the Elephant framework. Neuroinformatics 2018, P19. -doi: 10.12751/incf.ni2018.0019** +doi:10.12751/incf.ni2018.0019** A BibTeX entry for LaTeX users is: @@ -27,7 +40,7 @@ A BibTeX entry for LaTeX users is: } -Further publications directly related to Elephant development +Further publications directly related to Elephant development :cite:`citations-Rostami17_3,citations-Stella19_104022` (see a list of full `BibTex references `_ used in Elephant documentation). diff --git a/doc/tutorials.rst b/doc/tutorials.rst index 18e907f10..a6a326dd0 100644 --- a/doc/tutorials.rst +++ b/doc/tutorials.rst @@ -94,3 +94,4 @@ Additional tutorials/statistics.ipynb tutorials/unitary_event_analysis.ipynb tutorials/granger_causality.ipynb + tutorials/spade.ipynb From 4979f253e91ab7fa425cc4e47c61830746443735 Mon Sep 17 00:00:00 2001 From: pbouss <34713558+pbouss@users.noreply.github.com> Date: Fri, 25 Mar 2022 16:49:06 +0100 Subject: [PATCH 45/63] Boundary correction rate for firing rate estimator with Gaussian KDE (#414) Co-authored-by: stellalessandra --- .travis.yml | 1 - elephant/statistics.py | 43 +++++++++++++++-- elephant/test/test_spade.py | 5 +- elephant/test/test_statistics.py | 82 ++++++++++++++++++++++++++------ 4 files changed, 107 insertions(+), 24 deletions(-) diff --git a/.travis.yml b/.travis.yml index 43be16787..70df09a2e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -74,4 +74,3 @@ install: script: pytest --cov=elephant --import-mode=importlib - \ No newline at end of file diff --git a/elephant/statistics.py b/elephant/statistics.py index 1fa076f5e..6ad8bb3bc 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -74,6 +74,7 @@ import numpy as np import quantities as pq import scipy.stats +from scipy.special import erf import elephant.conversion as conv import elephant.kernels as kernels @@ -601,7 +602,7 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): @deprecated_alias(spiketrain='spiketrains') def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, - center_kernel=True): + center_kernel=True, border_correction=False): """ Estimates instantaneous firing rate by kernel convolution. @@ -625,10 +626,12 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. If 'auto', the optimized kernel width for the rate estimation is - calculated according to :cite:`statistics-Shimazaki2010_171` and with - this width a gaussian kernel is constructed. Automatized calculation - of the kernel width is not available for other than gaussian kernel + calculated according to :cite:`statistics-Shimazaki2010_171` and a + Gaussian kernel is constructed with this width. Automatized calculation + of the kernel width is not available for other than Gaussian kernel shapes. + Note: The kernel width is not adaptive, i.e., it is calculated as + global optimum across the data. Default: 'auto' cutoff : float, optional This factor determines the cutoff of the probability distribution of @@ -665,6 +668,14 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. Default: True + border_correction : bool, optional + Apply a border correction to prevent underestimating the firing rates + at the borders of the spike trains, i.e., close to t_start and t_stop. + The correction is done by estimating the mass of the kernel outside + these spike train borders under the assumption that the rate does not + change strongly. + Only possible in the case of a Gaussian kernel. + Default: False Returns ------- @@ -766,6 +777,12 @@ def optimal_kernel(st): "instantaneous rate from input data.") return kernels.GaussianKernel(width_sigma * st.units) + if border_correction and not \ + (kernel == 'auto' or isinstance(kernel, kernels.GaussianKernel)): + raise ValueError( + 'The border correction is only implemented' + ' for Gaussian kernels.') + if isinstance(spiketrains, neo.SpikeTrain): if kernel == 'auto': kernel = optimal_kernel(spiketrains) @@ -899,6 +916,24 @@ def optimal_kernel(st): units=pq.Hz, t_start=t_start, t_stop=t_stop, kernel=kernel_annotation) + if border_correction: + sigma = kernel.sigma.simplified.magnitude + times = rate.times.simplified.magnitude + correction_factor = 2 / ( + erf((t_stop.simplified.magnitude - times) / ( + np.sqrt(2.) * sigma)) + - erf((t_start.simplified.magnitude - times) / ( + np.sqrt(2.) * sigma))) + + rate *= correction_factor[:, None] + + duration = t_stop.simplified.magnitude - t_start.simplified.magnitude + # ensure integral over firing rate yield the exact number of spikes + for i, spiketrain in enumerate(spiketrains): + if len(spiketrain) > 0: + rate[:, i] *= len(spiketrain) /\ + (np.mean(rate[:, i]).magnitude * duration) + return rate diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index a85c1ed56..3736b330d 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -7,13 +7,12 @@ from __future__ import division import unittest -import random import neo from neo.core.spiketrainlist import SpikeTrainList import numpy as np import quantities as pq -from numpy.testing.utils import assert_array_equal +from numpy.testing import assert_array_equal import elephant.conversion as conv import elephant.spade as spade @@ -289,8 +288,6 @@ def test_parameters(self): elements_msip_max_spikes = [] for out in output_msip_max_spikes: elements_msip_max_spikes.append(out['neurons']) - elements_msip_max_spikes = sorted( - elements_msip_max_spikes, key=len) lags_msip_max_spikes = [] for out in output_msip_max_spikes: lags_msip_max_spikes.append(list(out['lags'].magnitude)) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 77dce6772..d693e604e 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -17,10 +17,9 @@ import scipy.integrate as spint from numpy.testing import assert_array_almost_equal, assert_array_equal, \ assert_array_less - import elephant.kernels as kernels from elephant import statistics -from elephant.spike_train_generation import homogeneous_poisson_process +from elephant.spike_train_generation import StationaryPoissonProcess class isi_TestCase(unittest.TestCase): @@ -139,7 +138,8 @@ def test_mean_firing_rate_with_spiketrain(self): def test_mean_firing_rate_typical_use_case(self): np.random.seed(92) - st = homogeneous_poisson_process(rate=100 * pq.Hz, t_stop=100 * pq.s) + st = StationaryPoissonProcess( + rate=100 * pq.Hz, t_stop=100 * pq.s).generate_spiketrain() rate1 = statistics.mean_firing_rate(st) rate2 = statistics.mean_firing_rate(st, t_start=st.t_start, t_stop=st.t_stop) @@ -580,6 +580,9 @@ def test_rate_estimation_consistency(self): kernels_available.append('auto') kernel_resolution = 0.01 * pq.s for kernel in kernels_available: + border_correction = False + if isinstance(kernel, kernels.GaussianKernel): + border_correction = True for center_kernel in (False, True): rate_estimate = statistics.instantaneous_rate( self.spike_train, @@ -588,7 +591,9 @@ def test_rate_estimation_consistency(self): t_start=self.st_tr[0] * pq.s, t_stop=self.st_tr[1] * pq.s, trim=False, - center_kernel=center_kernel) + center_kernel=center_kernel, + border_correction=border_correction + ) num_spikes = len(self.spike_train) auc = spint.cumtrapz( y=rate_estimate.magnitude[:, 0], @@ -616,9 +621,9 @@ def test_not_center_kernel(self): def test_regression_288(self): np.random.seed(9) sampling_period = 200 * pq.ms - spiketrain = homogeneous_poisson_process(10 * pq.Hz, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + 10 * pq.Hz, t_start=0 * pq.s, t_stop=10 * pq.s + ).generate_spiketrain() kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) # check that instantaneous_rate "works" for kernels with small sigma # without triggering an incomprehensible error @@ -636,9 +641,9 @@ def test_small_kernel_sigma(self): sampling_period = 200 * pq.ms sigma = 5 * pq.ms rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate_expected, - t_start=0 * pq.s, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + rate_expected, t_start=0 * pq.s, t_stop=10 * pq.s + ).generate_spiketrain() kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() if isinstance(kern_cls, type) and @@ -777,8 +782,8 @@ def test_instantaneous_rate_regression_245(self): def test_instantaneous_rate_grows_with_sampling_period(self): np.random.seed(0) rate_expected = 10 * pq.Hz - spiketrain = homogeneous_poisson_process(rate=rate_expected, - t_stop=10 * pq.s) + spiketrain = StationaryPoissonProcess( + rate=rate_expected, t_stop=10 * pq.s).generate_spiketrain() kernel = kernels.GaussianKernel(sigma=100 * pq.ms) rates_mean = [] for sampling_period in np.linspace(1, 1000, num=10) * pq.ms: @@ -842,6 +847,51 @@ def test_annotations(self): self.assertIn('kernel', rate.annotations) self.assertEqual(rate.annotations['kernel'], kernel_annotation) + def test_border_correction(self): + np.random.seed(0) + n_spiketrains = 125 + rate = 50. * pq.Hz + t_start = 0. * pq.ms + t_stop = 1000. * pq.ms + + sampling_period = 0.1 * pq.ms + + trial_list = StationaryPoissonProcess( + rate=rate, t_start=t_start, t_stop=t_stop + ).generate_n_spiketrains(n_spiketrains) + + for correction in (True, False): + rates = [] + for trial in trial_list: + # calculate the instantaneous rate, discard extra dimension + instantaneous_rate = statistics.instantaneous_rate( + spiketrains=trial, + sampling_period=sampling_period, + kernel='auto', + border_correction=correction + ) + rates.append(instantaneous_rate) + + # The average estimated rate gives the average estimated value of + # the firing rate in each time bin. + # Note: the indexing [:, 0] is necessary to get the output an + # one-dimensional array. + average_estimated_rate = np.mean(rates, axis=0)[:, 0] + + rtol = 0.05 # Five percent of tolerance + + if correction: + self.assertLess(np.max(average_estimated_rate), + (1. + rtol) * rate.item()) + self.assertGreater(np.min(average_estimated_rate), + (1. - rtol) * rate.item()) + else: + self.assertLess(np.max(average_estimated_rate), + (1. + rtol) * rate.item()) + # The minimal rate deviates strongly in the uncorrected case. + self.assertLess(np.min(average_estimated_rate), + (1. - rtol) * rate.item()) + class TimeHistogramTestCase(unittest.TestCase): def setUp(self): @@ -909,8 +959,9 @@ def test_time_histogram_output(self): def test_annotations(self): np.random.seed(1) - spiketrains = [homogeneous_poisson_process( - rate=10 * pq.Hz, t_stop=10 * pq.s) for _ in range(10)] + spiketrains = StationaryPoissonProcess( + rate=10 * pq.Hz, t_stop=10 * pq.s).generate_n_spiketrains( + n_spiketrains=10) for output in ("counts", "mean", "rate"): histogram = statistics.time_histogram(spiketrains, bin_size=3 * pq.ms, @@ -931,7 +982,8 @@ def test_complexity_pdf_deprecated(self): spiketrain_a, spiketrain_b, spiketrain_c] # runs the previous function which will be deprecated targ = np.array([0.92, 0.01, 0.01, 0.06]) - complexity = statistics.complexity_pdf(spiketrains, binsize=0.1*pq.s) + complexity = statistics.complexity_pdf( + spiketrains, bin_size=0.1*pq.s) assert_array_equal(targ, complexity.magnitude[:, 0]) self.assertEqual(1, complexity.magnitude[:, 0].sum()) self.assertEqual(len(spiketrains)+1, len(complexity)) From e97479bd76bb219a26bedebd19e018408ea78f81 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 25 Mar 2022 16:51:03 +0100 Subject: [PATCH 46/63] Neo v0.10.0, remove support for python 3.6 (#460) * added CI.yml containing workflows * added badge for CI tests to README.md * restructured requirements, environment.yml refactored to environment-docs.yml and environment-tests.yml. * adapted runners according to new new .yml files * re-add environment.yml for Travis, to be removed together with travis.yml * update requirements in environment-*.yml to neo>=0.10.0 * updated .yml files to python version 3.7 * removed python 3.6 from docs 'install.rst', added python version requirement to `setup.py` * rename travis conda 3.6 extras,opencl runner * updated build_wheels workflow to exclude python 3.6 * removed redundant line * changed structure of installation for docs runner * added extras to docs runner * added trigger for github actions CI: run tests after merged PR * added classifiers to setup.py (python >=3.7), removed classifiers for python 2 * add python 3.10 * update cibuildwheel version to 2.3.1 --- .github/workflows/CI.yml | 15 ++++++++++----- .github/workflows/build_wheels.yml | 6 +++--- .travis.yml | 6 +++--- doc/install.rst | 2 +- requirements/environment-docs.yml | 3 ++- requirements/environment-tests.yml | 3 ++- requirements/environment.yml | 2 +- setup.py | 19 ++++++++++++------- 8 files changed, 34 insertions(+), 22 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index de04a89c1..2119be6c1 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -36,6 +36,9 @@ on: #- review_request_removed #- auto_merge_enabled #- auto_merge_disabled + push: + branches: + - master # jobs define the steps that will be executed on the runner jobs: @@ -44,8 +47,9 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - # python versions for elephant: [3.6, 3.7, 3.8, 3.9] - python-version: [3.6, 3.7, 3.8, 3.9] + # python versions for elephant: [3.7, 3.8, 3.9, "3.10"] + python-version: [3.7, 3.8, 3.9, "3.10"] + # OS [ubuntu-latest, macos-latest, windows-latest] os: [ubuntu-latest] @@ -214,7 +218,8 @@ jobs: strategy: matrix: # python versions for elephant: [3.6, 3.7, 3.8, 3.9] - python-version: [3.6] + python-version: [3.9] + # OS [ubuntu-latest, macos-latest, windows-latest] os: [ubuntu-latest] @@ -282,7 +287,6 @@ jobs: run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH - sudo apt install -y libopenmpi-dev openmpi-bin - name: Cache pip uses: actions/cache@v2 @@ -301,6 +305,7 @@ jobs: conda env update --file requirements/environment-docs.yml --name base conda install -c conda-forge openmpi conda install -c conda-forge pandoc + pip install -e .[extras] # run notebooks sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py @@ -313,4 +318,4 @@ jobs: - name: make html run: | cd doc - make html \ No newline at end of file + make html diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml index 46cd527d8..22cb9f3b5 100644 --- a/.github/workflows/build_wheels.yml +++ b/.github/workflows/build_wheels.yml @@ -25,7 +25,7 @@ jobs: - uses: actions/setup-python@v2 - name: Install cibuildwheel - run: python -m pip install cibuildwheel==1.10.0 + run: python -m pip install cibuildwheel==2.3.1 - name: Install libomp if: runner.os == 'macOS' @@ -34,8 +34,8 @@ jobs: - name: Build wheels run: python -m cibuildwheel --output-dir wheelhouse env: - CIBW_SKIP: "cp27-* cp33-* cp34-* cp35-* pp*" - CIBW_PROJECT_REQUIRES_PYTHON: ">=3.6" + CIBW_SKIP: "cp27-* cp33-* cp34-* cp35-* cp36-* pp*" + CIBW_PROJECT_REQUIRES_PYTHON: ">=3.7" CIBW_ARCHS: "auto64" - uses: actions/upload-artifact@v2 diff --git a/.travis.yml b/.travis.yml index 70df09a2e..ddfb4bcfe 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,8 +8,8 @@ addons: matrix: include: - - name: "conda 3.6 extras,opencl" - python: 3.6 + - name: "conda 3.7 extras,opencl" + python: 3.7 env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin before_script: @@ -32,7 +32,7 @@ matrix: env: DISTRIB="pip" - name: "docs" - python: 3.6 + python: 3.7 env: DISTRIB="conda" before_install: sudo apt install -y libopenmpi-dev openmpi-bin before_script: diff --git a/doc/install.rst b/doc/install.rst index 541e44565..98e2b09ee 100644 --- a/doc/install.rst +++ b/doc/install.rst @@ -14,7 +14,7 @@ Below is the explanation of how to proceed with these two steps. Prerequisites ************* -Elephant requires `Python `_ 3.6, 3.7, 3.8, or 3.9. +Elephant requires `Python `_ 3.7, 3.8, 3.9 or 3.10. .. tabs:: diff --git a/requirements/environment-docs.yml b/requirements/environment-docs.yml index c9da5d22c..2068f16e5 100644 --- a/requirements/environment-docs.yml +++ b/requirements/environment-docs.yml @@ -4,7 +4,8 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 + - mpi4py - numpy - scipy diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml index c9da5d22c..2068f16e5 100644 --- a/requirements/environment-tests.yml +++ b/requirements/environment-tests.yml @@ -4,7 +4,8 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 + - mpi4py - numpy - scipy diff --git a/requirements/environment.yml b/requirements/environment.yml index c9da5d22c..00f3e8cc4 100644 --- a/requirements/environment.yml +++ b/requirements/environment.yml @@ -4,7 +4,7 @@ channels: - conda-forge # required for MPI dependencies: - - python>=3.6 + - python>=3.7 - mpi4py - numpy - scipy diff --git a/setup.py b/setup.py index 57ab67d43..ed2c0f1f7 100644 --- a/setup.py +++ b/setup.py @@ -29,12 +29,12 @@ '-Dfim_EXPORTS', '-fopenmp', '/std:c++17']) elif platform.system() == "Darwin": fim_module = Extension( - name = 'elephant.spade_src.fim', - sources = ['elephant/spade_src/src/fim.cpp'], - include_dirs = ['elephant/spade_src/include'], - language = 'c++', - libraries = ['pthread', 'omp'], - extra_compile_args = [ + name='elephant.spade_src.fim', + sources=['elephant/spade_src/src/fim.cpp'], + include_dirs=['elephant/spade_src/include'], + language='c++', + libraries=['pthread', 'omp'], + extra_compile_args=[ '-DMODULE_NAME=fim', '-DUSE_OPENMP', '-DWITH_SIG_TERM', '-Dfim_EXPORTS', '-O3', '-pedantic', '-Wextra', '-Weffc++', '-Wunused-result', '-Werror', '-Werror=return-type', @@ -67,13 +67,18 @@ long_description=long_description, license="BSD", url='http://python-elephant.org', + python_requires=">=3.7", classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: BSD License', 'Natural Language :: English', 'Operating System :: OS Independent', - 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', + 'Programming Language :: Python :: 3.10', + 'Programming Language :: Python :: 3 :: Only', 'Topic :: Scientific/Engineering'] ) From 7a6d3f25759368e66f080fe6d745f9d73d0ddd13 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Mon, 28 Mar 2022 09:19:36 +0200 Subject: [PATCH 47/63] Fix/update tutorials asset and unitary_event_analysis to use nixio 1.5.0 (#441) * updated UE tutorial and requirements to use nixio 1.5.0 (#86) * updated links for datasets used in tutorials asset and UE * use 'read only' to assure backwards compatibility * reset outputs of notebook * remove permalinks from tutorials asset and UE * hotfix fixed jinja2 version to 3.0.3 * changed URLs to elephant-data master --- doc/tutorials/asset.ipynb | 46 +++++++++++++--------- doc/tutorials/unitary_event_analysis.ipynb | 23 ++++++----- requirements/environment-docs.yml | 2 +- requirements/requirements-tutorials.txt | 2 +- 4 files changed, 42 insertions(+), 31 deletions(-) diff --git a/doc/tutorials/asset.ipynb b/doc/tutorials/asset.ipynb index bb2e7e328..ec61445bf 100644 --- a/doc/tutorials/asset.ipynb +++ b/doc/tutorials/asset.ipynb @@ -83,9 +83,19 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 42.1M 0 42.1M 0 0 3064k 0 --:--:-- 0:00:14 --:--:-- 5532k\n" + ] + } + ], "source": [ - "!curl https://web.gin.g-node.org/INM-6/elephant-data/raw/master/dataset-2/asset_showcase_500.nix --output asset_showcase_500.nix --location" + "!curl https://gin.g-node.org/INM-6/elephant-data/raw/master/tutorials/tutorial_asset/data/asset_showcase_500.nix --output asset_showcase_500.nix --location" ] }, { @@ -124,7 +134,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -175,7 +185,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -226,7 +236,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqcAAAK5CAYAAACCOYfvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXxU1d348e8EAiogUCBmBYIQVhXBIGu1aopQq+XB0lIfi5ZCoahVUUpdyk/6lFqtiAsVoTxsBSwPlEfKIwKulU0CliUIhJgASQiBuLCFQEjm90c6554h92aWzMy9M/m8+8qrX2/O3DlJbm4u53vO97hExC0AAACAA8TZ3QEAAADAg4dTAAAAOAYPpwAAAHAMHk4BAADgGDycAgAAwDF4OAUAAIBj8HAKAAAAx+DhFAAAAHUaMmSIvP3221JUVCRut1vGjBnj8zW9evWSjz76SMrLy6WoqEieffZZv96Lh1MAAADUqXnz5pKTkyO/+tWvpLy83Gf7Fi1ayMaNG6W0tFQyMzPlkUcekSeffFIef/xxv97PzQcffPDBBx988MEHH/58nDlzxj1mzJg620yYMMF96tQp9xVXXKGOPf300+6ioiKf52fkFAAAACE1YMAA+eSTT6SiokIdW79+vaSkpEjHjh3rfG3jMPcNAAAAFqorPhaJa21rH/YddHk9RM6dO1fmzZtXr3MmJiZKUVGR17HS0lL1ucOHD1u+lodTAAAAu8S1FveXI23tQkXFMsnMzAz5ed1ut9d/u1wu0+OXI60PAACAkDp+/LgkJiZ6HUtISBARYwTVCg+nAAAANqq2+X/hsHXrVhkyZIg0bdpUHcvKypLi4uI6U/oiPJwCAADAh2bNmskNN9wgN9xwg8TFxUn79u3lhhtukLS0NBERmTFjhrz33nuq/bJly6S8vFwWLlwoPXv2lBEjRsjUqVNl5syZPt+Lh1MAAACbuN0iVe5qWz/8cdNNN8muXbtk165dctVVV8n06dNl165dMn36dBERSUpKkmuvvVa1P336tGRlZUlycrLs2LFDZs+eLS+99JJfD6cuqakpBQAAgAirurBHKr+8x9Y+7C1eEZYFUcFi5BQAAACOQSkpAAAA27ilmiS2F0ZOAQAA4Bg8nAIAAMAxSOsDAADYxC0Stlqj0YqRUwAAADgGI6cAAAA2qvKx13xDw8gpAAAAHIOHUwAAADgGaX0AAACb1CyIIq2vY+QUAAAAjsHDKQAAAByDtD4AAIBt3FJFWt8LI6cAAABwDEZOAQAAbMKCqNoYOQUAAIBj8HAKAAAAxyCtDwAAYCO2L/XGyCkAAAAcg5FTAAAAm9QsiIKOkVMAAAA4Bg+nAAAAcAzS+gAAADZihyhvjJwCAADAMXg4BQAAgGOQ1gcAALCJW0SqyOp7YeQUAAAAjsHIKQAAgI2oc+qNkVMAAAA4Bg+nAAAAcAzS+gAAADZxi0iVuOzuhqMwcgoAAADHYOQUAADARtWUkvLCyCkAAAAcg4dTAAAAOAZpfQAAAJuwIKo2Rk4BAADgGDycAgAAwDFI6wMAANiEtH5tjJwCAADAMRg5BQAAsIvbJdVuRk51UTFyOnHiRMnPz5fz58/Ljh07ZPDgwXZ3CQ42bdo0cbvdXh8lJSW12hQXF0t5ebl8+OGH0qNHD5t6C6cYMmSIvP3221JUVCRut1vGjBlTq42v66ZVq1ayePFi+eabb+Sbb76RxYsXS8uWLSP1JcAhfF1LCxYsqHWP2rp1q1ebJk2ayKuvvionT56Us2fPyttvvy0pKSmR/DIA2zj+4XTUqFHyyiuvyIwZM+TGG2+ULVu2yLp16yQtLc3ursHBDhw4IImJierjuuuuU5+bMmWKTJ48WR5++GHJzMyUEydOyMaNG6V58+Y29hh2a968ueTk5MivfvUrKS8vr/V5f66bZcuWSZ8+fWTYsGFy5513Sp8+fWTJkiWR/DLgAL6uJRGRjRs3et2jhg8f7vX5WbNmyciRI2X06NEyZMgQufrqq2Xt2rUSF+f4P9tAvbmkZi6uY23btk327Nkj48ePV8dyc3Nl5cqV8tRTT9nYMzjVtGnT5N577/V6INUdO3ZMXn/9dZkxY4aIiFxxxRVy4sQJeeKJJ2Tu3LmR7Coc6syZM/LQQw/JokWL1DFf1023bt1k//79MmjQINmyZYuIiAwaNEg2bdokXbt2ldzcXFu+FtjL7FpasGCBtG3bVr7//e+bvubqq6+WkydPyoMPPijLli0TEZHU1FQ5cuSIDBs2TDZs2BCRviMyzlbsloOld9nah+oTf5fMzExb+6Bz9D/B4uPjpW/fvrV+ETds2CADBw60qVeIBp06dZKioiLJz8+X5cuXS3p6uoiIpKenS1JSktc1VVFRIf/85z+5pmDJn+tmwIABcubMGfVgKiKyefNmOXv2LNcWahk8eLCUlpbKwYMHZe7cudKuXTv1ub59+0qTJk28rreioiLZv38/1xIaBEc/nLZt21YaN24spaWlXsdLS0slMTHRpl7B6T799FN54IEHZNiwYTJu3DhJTEyULVu2yLe+9S113XBNIRD+XDeJiYly8uTJWq89ceIE1xa8vPvuu/LTn/5Ubr/9dpk8ebL069dPPvjgA2nSpImI1FxLly5dkrKyMq/XcZ9CQxEVq/Xdbu+ZBy6Xq9YxwOPdd9/1+u9t27ZJfn6+jBkzRrZt2yYiXFMIjq/rxuwa4trC5f72t7+pOCcnR3bu3ClHjhyR733ve7J69WrL13Etxa4qm8cKnVYrwNEjp2VlZXLp0qVa/1JMSEioNYIBWDl37pzs27dPunTpIsePHxcR4ZpCQPy5bo4fPy4JCQm1XtuuXTuuLdSppKREioqKpEuXLiJScy01btxY2rZt69WO+xQaCkc/nFZWVsrOnTslKyvL63hWVpbXvC6gLk2bNpVu3bpJSUmJFBQUSElJidc11bRpUxkyZAjXFCz5c91s3bpVWrRoIQMGDFBtBgwYIM2bN+faQp3atGkjKSkpquTdzp075eLFi17XW0pKinTv3p1rKQa5RaT637VO7fpwmkYi8v/s7kRdTp8+LdOnT5eSkhI5f/68PPPMM3LLLbfIz372Mzl16pTd3YMDvfjii3LhwgVxuVySkZEhs2fPli5dusgvfvELOXXqlDRq1EieeuopOXjwoDRq1EhmzpwpSUlJ8otf/EIuXrxod/dhk2bNmkmPHj0kMTFRfv7zn8vevXvl1KlT0qRJEzl9+rTP66asrExuvvlmue++++Szzz6TtLQ0mTt3rmzfvl1ef/11u788RFBd11JVVZXMmDFDzpw5I40aNZLevXvL/PnzpXHjxvLQQw/JxYsX5cKFC5KcnCwPP/yw7N69W1q2bClvvvmmnD59WqZOnUpqP8Y89cxEOXn2LVv7EFc+SubNm2drHy7ndvrHxIkT3QUFBe6Kigr3jh073EOGDLG9T3w492P58uXu4uJi94ULF9xFRUXulStXurt37+7VZtq0ae5jx465z58/7/7oo4/cPXv2tL3ffNj7ccstt7jNLFiwQLXxdd20bt3avWTJEvepU6fcp06dci9ZssTdsmVL2782PpxzLV1xxRXud999111aWuq+cOGC+/Dhw+4FCxa4U1NTvc7RtGlT96uvvuouKytznzt3zr1mzZpabfiIjY8zFbvd2w53tPUjOzvb9u+D/uH4OqcAAACx6kzFHtlz/B5b+9Dk5ArqnAIAAABmoqKUFAAAQCxyi0iVm7FCHd8NAAAAOAYPpwAAAHAM0voAAAA2qmas0EvUfDfGjRtndxcQI7iWEApcRwgFriOgtog/nE6cOFHy8/Pl/PnzsmPHDhk8eLBfrxs/fnyYe4aGgmsJocB1hFDgOgJqi+jD6ahRo+SVV16RGTNmyI033ihbtmyRdevWSVpaWiS7AQAA4AhucUmVzR9OE9Ei/Nu2bZM9e/Z4/UsxNzdXVq5cKU899ZTl674sPyfllZXy1fnzckXhuUh0NWZ8q5exHedXOU1M21xzXYWKS/deEfY+2a1lu6vl1MnTdncDUY7rCKEQyHXUttcFFZflNDVtk3jdeRUf33tl/ToX467p0E5aJbS0uxtyqmKv7CgZaWsfri5b6qgi/BFbEBUfHy99+/aVP/3pT17HN2zYIAMHDqzVfty4ceohtryyUoYs+IuIiHR+bFv4OxtD7jtQpOKl/VJN2zyWt1/FL/frHvY+AQACNza3QMXz+6WbtvnNF3tU/Id+14e9T9Fs9vbn7e6CQp1TbxF7OG3btq00btxYSktLvY6XlpbKHXfcUav9vHnzZN68eSIicjA7Tz2U5r3cX7WxelD1eiDrZv5AFg0ePHhEREQWdO2gjo0+cEzFy7slq9jqa/bn63+5c3Q9kK4qMn7uI1P719HSPyuKtqp4VOqAep8PAEREns7fJSIiv+/UO6DXjc/NV/HcjE4qnp9h/kCq+8O1PJAi+kX8Ud3t9p5F4HK5ah0DAABAwxSxkdOysjK5dOmSJCYmeh1PSEioNZoKAADQELhFpNqBi5LsFLGH08rKStm5c6dkZWXJypUr1fGsrCxZtWqV3+fRU/lWKf5oTuXr9HS+h57KD9Ta4p0qviulb9DnsVugqXxP2t4qZU8qX2R10XYVj0jtZ2NPots7xZ+peHhKn5Cee/2xXSoemhxYmjjUYuVeEm6edP6kQ7nq2OwuGSE5t5N+BmuKs1V8d0poFtUEMn0r1FO9YL+I7hA1c+ZMWbJkiWzfvl02b94sEyZMkOTkZJkzZ04kuwEAAOAQLqmKnj2RIiKiD6crVqyQNm3ayDPPPCNJSUmSk5Mjw4cPl6NHj0ayGwAAAHCoiNY5DdbB7DyZ1G9qnW38WcXf0HmVIfFj1ScAwJkmHspT8RtdOtvYk+g1e/vz0jXT/u/dNxU5svnYj2ztQ8KXCxtmnVMAAAB4cwt1Ti/HdwMAAACOEXUjp1bF5v1ZxR8LrIrw66xWcTb0VL6TVjujYQnHamY0DFb382hI5XPdI1hR93AKAAAQS6pJZHvhuwEAAADHiLqRU38K7Edzit9qT2UPf4rw212Q2ansSuVTIBqkNJ1jaeFmFd+XNiis7/V0fs1UIk8x/mD4cz+fnLdPxS917hn0e4Ua171/3G6XVLnZIUrHyCkAAAAcg4dTAAAAOEbUpfUDZZbid1p631cxZX9WmVtVMQj2PSGyomirikelDgj6PKTy4SRMM7GXvvp+1dm2Kl7QtYOKfU3vgn+i5Vp3i7B96WX4bgAAAMAxYmb70kBE2yKp+gh0RBWxIVpGDAD4jy2oQ8sp25d+eX6fvF98v619SP/6TbYvBQAAQI1qti/1wncDAAAAjtEgR06dVgc12MVJPz1YqOLFXdNM2+ipfFJCDQepfMBgR21TEd/1TR88eETF+oIoK/p9m0WtscMtLhZEXYbvBgAAAByDh1MAAAA4RoNM6+uckOIPNiVzb/PjKl4s5ml9nZ4S0mvtbTjfTMWvdu4WVF/QcKwu2q7iEan9QnJO/Xpk+12EWrhT+bpAtiq96G6kYn+maekqquNV/EjeARUHeg9/8XDN37onO0bXVKBYq0jC9qXeGDkFAACAYzT4kVMAAAC7uEWkmrFCLw2yCL8/nLCKHwAAhIdTivCfPP+5/F/hWFv70PPUq44qws+jOgAAAByDtD4AAIBtXFLFDlFeeDi1YNcq/oG7L6p4yw1NRESk77+q1bGdNxoXcOauKhVn9zZWfQJAOIWjYkOkPJdvVIaY1im8lSE8K/D11fdDc06reH2vq8P6/kC04lEdAAAAjsHIKQAAgE1qVutT51THw6kfIpni96TyRUTOvdtJRER23phv2tafVH7TjxNVfOEWo2h/oHs6A4BHtKXydeFO5es86fz4j5LUsfW9gj9fi0/aqnhY2xwVr+ieaNYciFo8nAIAANiIBVHe+G4AAADAMRg5DVAkU/zFJa1FRCTD4vO5/32TijN+tsO0jZ7K1+mp/LG5BSqen5Gu4kmHclU8u4tVL+AUnj2yRaJvn2wEb+HRTSp+oP1gG3sS+wr+MEDF6b/Z6vfrKm8t8X3u5TcY5x6927TNmSFlKl4hRiqfezViDQ+nAAAANnGLS6pIZHvhuwEAAADHcElNFQNHO5idJ5P6TbW7G3UKVYo/2LQRos/kvH0qfqlzTxt7AjiXVcWRYBWtMn7XUkfuq6Nl/eW/UHM/7zSFe7kTzd7+vHTN7Gx3N6S0/ICsODLR1j70P/uCZGZm2toHHSOnAAAAcAweTgEAAOAYLIgKkfqs4i+eOlDF6b/ZUut4yvNbar0mGIdevVnFXR75NCTnjAW9/2XEu26M3Pvqqfzf5n8mIiLTO/WJ2Pv/riBbxc+mOyedA+hCkco/8XY3FafeE1gq/+QEY6pVuzm+0/Oljxj3805TQnPvNpM71/idzRifXUdLOJ1bhAVRl+G7AQAAAMfg4RQAAACOQVo/DAJN8etp+5LJRkoo7mLd76O3TXrJOMexJ4zjyX8yjuup/EOLjPRxlzGf1f1GMS6SqXwrnnS+J72vHwuXWE7lzzxspF8f7zigjpZoCBLuOaDiwpXG5vZp9+aYNffiTypfd82rxj332uwrRETki8wKn68rfMa4b6f9l3GOwme147/TpglccgXUL92UL/aq+IVrrwv6PAgVl1SzfakXvhsAAABwDEZOAQAAbFKzICr4kfBYRBH+CAp0Ff+X42rSkW3mUcAZAKLViUlGaj5hdvhW8CMwTinCX1J+UP56+GFb+3Drud9ThB8AAAAwQ1ofAADARiyI8sbDaQQFuorfLJ1/5kfG6/QpKi3eMs5xerTR5urlxvFAU0uB7EE96VCuimd3yfB5bru1/7SZiuelbVbx2KODVVzU/2xE+yQiMvFQnorf6GKebhqfm296fG5Gp7D0yV9P5+9S8e879TZt85sv9qj4D9deH5L3DfXKYzs2J4iGDRH0n12cq1rF+s86HD/fQBz/3+4qTvzBfhWvP2Zcm9sqqlQ8rVNfn+f0TK8SsZ5i9doR4x6SEW/cW/pPmSAi1vfbrx8wzt16oe/pW3pfLrQy/gAkvxjaqQJOux5fPFz7b+STHfubtESs4FEdAAAAjsHIKQAAgE3c4mK1/mUa1Gp9T8pUT5f6k0YNVPFUI32uF9i3EugqfjMXhpunXpq+48w9lwOdBvDgwSMqXtC1Q0Dv1XJTGxEROTX4S9PP6ym/nxR8R8VxLuNX4+TAbwJ6z2CNzS1Q8fyMdJ/H7ztQZHqepd1Sw9C74OjTEPSpB/X5mYbC5DxjqspLnXvW0dJ5HsszUtYX3Y1UbPW7ZPUz0OnXUrDXj5O+p8V/N94/p/9S0zZDk82nn/jj7A9vVvHGl19T8VVxTVR8wV0pIiJ3pwSWGj93782mx5ut/NT0uN2ctOnFjILtKn4qvV+dbZ2yWv9Yea4sLPiVrX3IKp/uqNX6jJwCAADYiAVR3vhuAAAAwDFifuRUT2eZpe39SeUP3G1scr/lhiambQr+YKQy0n9jpPJLJhsp/qSXzFP8Vqv409+ued9GH31W6zUiIodeMdp2+ZX5dIBLtxurUSubG+m/cz830tRtv58roaRPlYgTY1WvnnIMdEV/fdK+nnR+i0/aqmN/7vi2iocmD1LxwqP/UHFS4+ZGGwk+/Ze6zTiPXgFg5P4TKl7VPUFERCqq49Wxnx4sVLGeytdVuo1f4f+82mi/VEKT1l9TbEwL8aQm9SkGjbRZQVbp4nCn8vV09OgWpSIisq68hTpmda3paWd/Kg34448FRtr11+nmqdlg6d/3lzsbq9L176mVc9XGfcvqZxBIKl+fVqD3pZG2ij9ULm40+tgky+j7V2trfq7fusv8/lVdbczh09P3+jQePdbb+LNa/csflqt4RKqRPn6n2LhfN3XV/D5XfvcmdSx+ww7T8+kCTd+fnGD8/Wk3x/eq/9w3jP5mTNxeR0vva/qquEsqfrjDILPmIWP2O+nP7+k5t/nfaESXmH84BQAAcCq3iFSR1vfCdwMAAACOEXWr9e1e4XvuXSNFWVzSWsUZD+40jmur9eOMGQHS5IzxrbYq5lx1ax8VF9xTk56wXMHfXytyvW2PeRtNoKml448ZX0fiy+HbD1pPV+ppbX/SjI0+TFZxVbX2b63bjVSv64MUERFx31asjl358TWm56vWynlcuOW4z/e34qkQIGJdJeCufV+reG3PmmtpxOcn1bHVPdoF9J7D9hlTNdb1bOWz/dCc0ype3+tqv9v701YX6NcU6Neh80yFWNw1LaDXOWmVuT/0+2CF2/idWd4t2ay5pbs/N67NNT3a1NHSP4/kHVDxq527BX2ezF1Gofzs3o1M25x4u+b8CfccMP287sgKY3OGDqOMTRv0aVRf/GiOis9WV6h4S4UxReTZ536u4lZLzO/h+lSq95fMr/V5ffpA9S03qtjt0koJaWGjD82ndZ2/x0jNX/l23an5aOf5/azP76bZ77hTVusXlx+SuV9MtrUPd1U866jV+oycAgAAwDGibuS0PjyT3wOtbdf3X8Yk/503Rv553p86qK4bjX9Ruv9V91ajkbS22BhRXn7GGK3UR0X1Nnel+N5O0Mv72ujq7eY1P83oI6fnbykNuk38R0kqrry1xLRNm83GCPuXg742bRNqt+w5r+KPr78yoNf2312p4m03xNfR0lugI7FWbtt7TsVN44y+BDqK6lGv68sPwS6mCkeNZZ3ZgjsR/0ZLPaP6nhH9YFgtmooUq9HSSDr0es2iuLjzxt+NvPveUPGGcuP360/3/8T3CeOMIVXX5l11NAwPqwVk4RCKLbH1c+g852Pk1ODvyOnEiRPlySeflKSkJNm3b588+uijsmnTJsv2o0ePlilTpkhGRoacPn1a3nvvPXniiSektNT8b6oHI6cAAAA2cbtrFkTZ+eGPUaNGySuvvCIzZsyQG2+8UbZs2SLr1q2TtDTzaVQDBw6UJUuWyKJFi6Rnz57ygx/8QHr06CFLl5pviqHj4RQAAAB1evzxx2XhwoXyl7/8RQ4cOCCPPPKIlJSUyMSJE03bDxgwQIqKimTWrFly+PBh+fTTT+W1116Tm2/2XWYv6tL6ow8cU8etJv/708ZuZ35kpOpb/M3/LUv9SfE36tlVxVX7DgbRuxqnRxvvdfXy4LZVDQuLVL6+WK3Znfnir3lHjZTEuPaD69e3CKvP4qFQq89UAifxZ6vP+jDbRrk+Qr2oqT6sFqzWZwrDqXeM9i2H59XR0lrB8htUnD56d1Dn8Nel24ypI40/2Fnr8/oUrJ/9ba2K72lWpmJ9u1NXX23K1k7nTNkKVKhqCYeSU9L6RecOyZwvnrS1D/dceLrOtH58fLyUl5fL6NGjZeXKler466+/Lr169ZJbb7211mv69+8vH3/8sYwcOVLWrl0rbdq0kaVLl8qpU6fkRz/6UZ39YeQUAADARtVul60fbdu2lezsbPUxbtw4r/61bdtWGjduXGuuaGlpqSQmJpp+Tdu2bZPRo0fL0qVL5eLFi1JWViYul0vGjBnj8/tBEX4AAIAGrKyszK8FUW63d7Ld5XLVOubRvXt3efXVV+V3v/udrF+/XpKSkuTFF1+UN9980+cDatQ9nPqTpg8kla9vEXlvc6OupZ5Wsaq5l/vfRt3QjJ+Z1w213L7UZdJYLtuSdPm/t8fTaphabXWqHw80lX/he8bXeulKYzD97Chj9fXVywM6pU9mNT79pqXyL2zoqOJm3607lT/niJG+n9DBSN/rqXxPTVQR77qoOn9W8VvRv+4q7SIINiWvv05fLa/Xiw11it0qfV+f9wm0QoBVZQBPTdVAa8Tq/EnlW61Efy7fSONO6xT6ygC+1KdOru6OnDMiIvJerxamn7dK31vVnq7PFIZAUvlH/8dYod/+h8YKfT2Vn7fEqC0qJ5uqsPPjgU1dOjfSmDfX5IzxN0KvIX3otZo2XR42tgDVq6mMan5KO6Nx3XtVX/Ejla//LUr5P+NvVLNVvrdBLXy25m9U2u9817K2mvLiz3avoUjlh2IFv36edikVPlpGhltcUuXwRHZZWZlcunSp1ihpQkKC5cr73/zmN7J9+3b505/+JCIie/fulXPnzsmmTZvk6aeflqIi6wo7zv5uAAAAwFaVlZWyc+dOycrK8jqelZUlW7aY/8PmqquukqqqKq9jnv92uSxG6P4t6kZOAQAAEFkzZ86UJUuWyPbt22Xz5s0yYcIESU5OljlzanZXW7RokYiIStn/4x//kHnz5smECRNUWn/WrFmyc+dOKSwstHwfkShcrX/fAfNhYH+2uvS81p+2kXRhuJEGafpOdq3P+1Ng369C/ZlGysudbaS8rN4/2IoCOj0FPuBbRkrog+uaqXjUfmM6xYru5hOrvVis1j+rrdZvHsBqfX94bZP6nWN1tPRfKFbaryk2fl76VBQ99a6zSr1bbTTRdYeRamwad0lERJo3uqCObbmhiYoH7r5oetyK/p7xcca/rgMp/C9ipKBFjDS0VcUOfRpPoFuc1kcg26Na9V1P2T/Y8rCK9Z+7P/TrrrzKSGvr14bne3qVtv9yszjj536Fy5iGUZ9tpEOVpvWl4C1jq+f0HxvTpPJmavdNLa1/4iFjOlbC6+HbullX/b5xPW7s/g8Vh7vYfSDCvXGEzuzasLpe/LmOzAry35KyTL51Za9697W+Cs/lyauH6r/RUH2Mqvy130X4p0yZIklJSZKTkyOPPfaYfPLJJyIi8uGHH4qIyHe+8x3V/qGHHpIJEyZIenq6nDp1Sj788EOZMmWKFBebT5vzYOQUAAAAPr3xxhvyxhtvmH5Ofyj1eP311+X1118P+H14OAUAALCJW0SqWQLkJeoeTv1JyVvtpW1HOv/YE0Z6KPlPRnpIL3Df9JT3hOHL6al8qwL7Vqv4M+YbKbzq7MD2l7ZK5Zc8rlUgmFl3yktfzf6BNDNto6fyw1lUXl+tP/ELowCw16p8iykDoUrlh4Ke3vUnpRvoKvpeO42bZE7fylqfH2hRw9wqxV9tUZrCO31vvKee7p9xjZGCtUpvWq0o97C6H1gZm1ug4vkZ6T7b++P2K42U+Es+2lpVG9FX368WI9aL8OusCvL78x5j0zsAACAASURBVHtl9j3VpxvUJ5VvB69U/l+11fonzNtHKpWvi7vdmHIy9P27VLz+mFGo/67cYSquvLVExb6mhl3uxCRt2sJs/7/WQFP59Sm8b5aet0rZB5ri9xzvsf2KgPqEyOFRHQAAAI4RdSOnAAAAsaTKXXdppYYmKlbrnzz/uaw9+jMRCU1qXl/xH+j5mn5spKAv3HK8jpbBuXS7ti/z+7X3ZfZHXK9uKs4da6TwrFbxO8nqou0qHpHaz2f7+I+SVKynucKxut6JRu438pIXtML7lW6jELdepN4OVqv4rTa3iAaBrL73h9VUgoArWWhCtbo/mpx427j3JdxzwGf73DnGPSZjwvY6Wtb4cuwAFbeZv1XF+kYmcZXan9Tqmjj+PfN7uauvdu1odR/dO3KMwzcZq8nfXfNXFY8rHKTiozef89n3WPNInvnP93tXGYX1fVU6mL39eemaGd6qA/44ei5PZuY+bWsf7rv0hF+r9SOFtD4AAAAcg7Q+AACATdzikmrS+l6iIq2vF+HX6atwV5/7looDWWEbjpW5h1419lzu8oj53sZWqyXP32OkmRqfr1m1rO/VbMWqwL7OqlB/7gJjKkHyO8a/V5r/j+99mc0U/91IVW286U0VP6DtYW+1Kl9feWy12tiK9ypzY8X3qqKar3Vkav9ar7nckD1GSuiT632v5NT3eG8aZ6xsD7Tvnr3K67MKWk/x62l9f/qiF+3XV/evKDJSly+W1Vybegren2kYVue2Emgxf53nnuDPqvxwmFFgfD+eSvc9LSUQ+mp5vQh+hduYzmG10j9QnmtpVfeEkJwv0GkQevsd5cbmGoFWnjDTerPxt+LrQV/V+3x18VQG6Pyf//LZtnqweQo6bpOx4l3/mxfvMn4PcyuNtP7DHYx0fyjoG6no1Vd0fyww/lb8Ov1m0zahYHUdBTvNxilp/SPnvpCXDtqb1r+/arKj0vqMnAIAANjFLVLtZpalju8GAAAAHCOq0/qB8uwLbFVI2J9i3Z70q4h/KdhDi/qouMuYz3y2L/uHUTS47fdr7wUcKlYp/nCySuVb7SVuN6f2y4rVFJX6VKfQ3ba3JnWoT1+wKuge6GYKd+37WsVre7YOqF/B/pxCveLeX1O+qJl288K11/lo6c2fKUhWbfT7li4UxfTt+j4Ga02xUaTeqnLBpffaq7jxHUeDfq9v7q9Z3R9fbkwzarYqsOlSld+9ScX6FK/1x3aZNZf5p4yqDoFWePDQp2al/Me+Olr678XDxt+ZJzv6nmLli17g34qvwv+OSeuf/UJePPisrX0YU/0YaX0AAADUjBBWWeyk11CR1gcAAIBjREVa/5uKHNlcXLMX+sudu4ftffSivq927lZHyxrhWOkfCL3ws9VPUd9nWV+Vn/GgMYVBT/EnGouzpfmKyBftt5paoRcUr3QbA/76vzat0seeQubBprjq4qSUpmfaikjge2BbVUnwpPJFRD64rlmdba3oKft41yUV63vFByqQ6TWP5e1XcTjvH7FIvyfGi7FpgtW1Xp+91HX+VD3wvJc/7xOqfrk+SFGx+7Zi0zZHpxmVWNo/V3vf+rM/NFaz6xVRykdoq9y1QbSr/q61+Y+bTY9bpfj7T5mg4pZ/df4mLJHmlLT+4bNfyB8P/tbWPvys+lHS+gAAAKhBnVNvpPUBAADgGFGR1g/Vav1Yc+5eI8XTbKXvFaBW6aSzo4y0/nFj6+iIreIPN89q9fqsVIe5aKho4FkdLxL4CnkgnE7dZ9x7Wy4N7H576j+N17rjfI+6tVq81WcbX5w0jSkUnJLWLzibLzP2/z9b+zBeHnZUWp+RUwAAADgGD6cAAABwDBZE1cOkQ0aR/NldMupoWVvRKiMlkjrSvMjx8cdqVn0mvmys+Dw92kjlnB1l7Ote3cg43uJv5ukhPZXvdVxbld95hXHcjkL94eArnR8rq7ntqB6hp/L92cTCDnoq/7l8o4/TOjmnj/VRn/tQrPltvrHRyfROfepo6Qx6Ov6rtcbPLu5vRhWMVkvM0/F2rL6PhVS+U1VT59QLI6cAAABwDEZOAQAAbOIWkSq7S0k5bOCW1frwS6yk+AEAEHHOav38s/ky/fPptvZhkmsSq/UBAAAAM6T1AQAAbOOSarfNY4UOS+vzcBqDSh439nZOmll7b+dg6Kl8UvwIhB1VBIBoc2yKcd9OfmGLz+P1cXSacc72z4XmnEAokdYHAACAYzByCgAAYBO3W6Ta7tX6DsPDaQwKVSrfilmKn/Q+rJDKB3yzStmHKpWvI5UPp+PhFAAAwEbsEOWNh1ObxMqWg54R02heJDXrsDGK8GjHgXW0dJ5o7jsQKa8d2azihzsMCvn5R+4/oeJV3RNUPDSnZovp9b2uDvl7ArGMBVEAAABwDEZOAQAAbMSCKG88nNrEKpU/8VCeit/oEtpt1Yr/3lPFKf+xL6TnjuY6qNGcDg9335/O36Xi33fqHdb3CoWFRzeJiMgD7Qfb3BM4iZ7KD0eKX0/l677V+Oy/o+hN61+bfYWKv8issLEnaEh4OAUAALCJ2wk7RDkM3w0AAAA4BiOnDhMn1bWOrS3eqeK7Uvqavu7Kj69R8flbSk3bbLzpTRU/IOFLewaa4n/w4BEVL+jaIWz98secI5tUPKFDdKWG1x8zUvAFlWdVHOjX8ceCT1X86/Sb69+xCPKk81cUbVXHRqUOsKs7yjvFn6l4eEqfOtuuKc5W8d0pmUG/51uFRiWHH6cFNv1jaWFN6vu+tNCvbLfbFS63zzah+h24r0WJiIgsl2R1zPO9FbH+/rbe/C0Vfz3oK9M2S7Tz3B/Gn5OeytfvMUOTIz/Nx5+/heF4LSKPh1MAAAAbsSDKG2l9AAAAOIZLRHznOGx2MDtPJvWbanc3bHPfgSIVL+2Watrmtr3nVPzBdc18nnPYvm9UvK5nq3r0zn/Rtoo/VtidikPDtLpou4pHpPazsSf204v0n60yVr/rxfk9BfsvP27lrn1fq3htz9b17WKDNHv789I1M7RVcYKRd+awTN3zvK19+HWTsZKZGfw0olAjrQ8AAGATt7B96eVI6wMAAMAxGDl1gEmHclVsVpzfKpUfaFrHjlS+zqmF+l88bLz/kx3719EyOvmTyp931KhSMC7EBez9WZ0MZ/FUO6hPpQMnpfIjeQ2aVR+xKtKvp/IDFeeqXdnFLtE2hcNTEaNpm3M+WkYOC6K8MXIKAAAAx+DhFAAAAI7Ban0HG5tbICIiI5oZRZitigeP2n9cxSu6J/o89+gDx1S8vFtyHS3rx58C+05K8SO8KX4gmj2db1S++H0n39NlPPc//d7nzyYLd3/+pdG+Rxufxz1/K0RE5mek++wXajhltf6h00dk8u4XbO3Ds1c84KjV+oycAgAAwDF4OAUAAIBjsFrfwSqq40XEv32A9VS+vip/fEujEsCC09eqWE/lh3PPYatUvs5Jq/ifyze+F9M6Rdf+ywu1dPwD9UjHx0Iqn320EQ7+pPJ1F92Nah2zSuXr9JS9blKrQqONGG3Kq5sG1C84i1tYrX85Rk4BAADgGIycAgAA2IiRU2+s1odj2Z3iBwDELqes1s89fUQe/defbO3Dc1f9lNX6AAAAgBnS+gAAADZxi0i1kNbX8XDqAP4Uqg+nEZ+fVPHqHu0i/v5WIrWKnwLWgLOsKNqq4lGpA0J67jlHjKoWEzqEvjKFXi1lXc9WIT+/Gavi/EC04uEUAADARiyI8sacUwAAADhG1I2crioyUrojU/vX0TJ6BJTKfz/ViG8vMj+u09tYqHQ7/zIIZ4qfVD7gW6g2efBHqFP5unCk8nW+UvkXNxr3+yZZR0zbXHqvvYrjXEZBnbjbC82aS6VJsX8gmjn/qQQAACBmuUjrX4a0PgAAABwj6kZOYyWV749GHyaLiEhVtfZvCC1Nf2FDRxU3vf2w6TniP0pSceWtJaZtqqKshEWkVvGHWyTTpHZqKF9nrONnFwTPdCvtvl1xyfizW7HuWhVfPewLFTe+42jd57vsnOVVTevZUcBZou7hFAAAIFa43azWvxxpfQAAADgGI6cOptL5Wvrm3LudVNzsu/kqPqsd1zW/1WjTa6fxb5GcvtUqjlSh6HCI5hR/Q0mTNpSvMxrN16ZcjOXnFHr/vnfr9+er7/zCqrVy6h1jv/dGcca9uvnt5vfzj6+/sl7dbAiWFm5W8X1pg2zsiTlGTr0xcgoAAADH4OEUAAAAjkFa38lMCug3uzPfpKFIc4vjnhX/IiI5fY+Fpl8OFc0pfsAOpPIjw+r+bKXl8DzzT2ir9XP6+t5gBQYnpvJ1btL6Xhg5BQAAgGMwcgoAAGATt4hUR1m98XCL6ofTFUVbVRzOvZjDreWmNio+NfhLFbs+SBEREfdtxUGfu+o7Rip/VZGR3tY3Mxi1/7iK412XVLy0m1bwOcqYpfit0vv+bFQAcxTYj5xYud/Zre+/jNXvO28MffJQX2nvSc9f3NhBHWuSdST4k2tTvfT7+V9PG8X8V/doF/z5o9RbhVtU/OO0gTb2BKESkt/MadOmidvt9vooKSmp1aa4uFjKy8vlww8/lB49eoTirQEAABBDQjZyeuDAAbn11lvVf1dVVal4ypQpMnnyZHnggQfk4MGD8tvf/lY2btwoXbt2lbNnzwb9nlajB+uP7VLx0OTeQZ8/UvTR0haftFXxmSF1j5jOOWKMWk3oMNjncautX1d0T/S/s1HIM2JqtUjKarS02T+NEYhz3z4Zpt5FN0ZL/bO6aLuKR6T2C+ocjJaGhj5a2vRj49534ZbjZs39cmy1MdiSPPxz4xP/XsDU5Hbz0dI/a/fqX3Yw/10K9H7uJJEa7Y/+0VIXdU4vE7KcxqVLl6S0tFR9lJWVqc89+uij8vzzz8vf//532bdvn4wZM0ZatGghP/nJT0L19gAAAIgBIXs47dSpkxQVFUl+fr4sX75c0tPTRUQkPT1dkpKSZMOGDaptRUWF/POf/5SBA63/tTNu3DjJzs6W7Oxsadnu6lB1EwAAAA7mkpqFYvVy5513SosWLeTAgQOSkJAgzzzzjHTr1k169uwpXbt2lS1btkj79u2lsLBQvWb+/PmSkpIid955p8/zH8zOk0n9pta3m47S/tNmKj568zkVL9G2WBuf/x+1Xnf+llKf5/YspBKp32KqWBbNdVD1a+R+B9Xuc2q/EDmRvAbu2ve1iIis7dna9PNDc06reH0vY4Aj3Aui9K1K21xZLiIir6evVMfGaVNhqt9PU3Gc/qfYpMa1yOXTvspM28B/s7c/L10zO/tuGGb7TxXK2E9fs7UPr7T+oWRmZtraB11I5py+++67Xv+9bds2yc/PlzFjxsi2bTV/+N1u72dgl8tV6xgAAAAatrAU4T937pzs27dPunTpIseP10wyT0z0XnSTkJAgpaW+RwEBAABildstUu122frhNGGpc9q0aVPp1q2bfPjhh1JQUCAlJSWSlZUlO3bsUJ8fMmSIPPnkkwGfOxpq/fX+lxHvutG8zbw0I/0l2q6iQ5ONVNiVH9f8v57Kn6fVlRxnsVI6VKn8x/L2q/jlzt3rbDvrsFFn7tGOvldOvnjYSKU/2dH3qtOxuQUqnp+R7rO9zlPHVF+V79StTq0qTczXfu73pxk/dz2NqrMjrZ7QqJnpcb2PVRbZEiet+l9TnK3iu1Mik+aqz2r+pdr312qLRn/q0erXmK9tTa3S91bXQDhYpfM9qrSi5vrvlW6o+K7mUvaPDBW3/X6uikv+17gn7um3XHuF8V5V7popBMNTzL+fcbcbU928U/zmIpXK9+fvjC4U1Sjqotcx9bBaoU/N09gQkpHTF198Ub797W9Lx44dpV+/frJy5Upp1qyZLFq0SEREZs2aJVOnTpURI0ZIz549ZeHChXL27FlZtmxZKN4eAAAAMSIkI6epqamyfPlyadu2rZw8eVK2bdsm/fv3l6NHj4qIyAsvvCBXXnmlzJ49W1q3bi2ffvqpfPe7361XjVMAAIBY4HZgat1OIVmtH26xuFo/dVtzFZ+vilfxS2n/UPEvCu4VEevi0Jar8t/Xth3VVn0O2VOh4k+uvyLwTgfBqoC0lefyd6p4Wqe+YelTXZyU4g9UQ10tb5bGsyM1H+ui+fq6ba9REWVS670qDkch+7XFxj3sntzvi4hIVbWWpLRYia+zum/qG4P0aWVMCYjU/TzWOGW1/uffFMqD22bb2ofX24x01Gr9sCyIAgAAAIIRlgVRAAAA8I8TV8zbqUGl9T0r/Z22yr/dllYq/mvHj1TsWa195cfXqGP+FOH3x+gDRomA5d2SQ3JOp9NTYue+fdJneztS/DMPG9Uo9KLc/lRAiJT6pHf9WTUOc9FQqSQa6Cv37z5kbAKjT5869Y6R6m05PM/0PMdW91Bx8ojPVXx63bUq3nrDKhHxrrxhNe0K3iKx6t5Jaf0xW/9sax/+3PY/HJXWZ+QUAADAJm6pqXUKA3NOAQAA4BgNKq0fyxp9aKTmq75zrI6WCEY0r+IHEF0sK7EgpJyS1t/3TaGM2WJvWv+NdqT1AQAAICIiLqkWFkTpSOsDAADAMRg5jWLeq/hJ5YeTnsonxQ8g1OI/SlJx5a2k8hsadojyxsgpAAAAHIOHUwAAADgGaf0o4J3uKVFxoAX5h+acVvH6XlereHLePhW/1LlnMF1sUEjxAwjWPG0jinHaRhT6vd1K683fUvHXg75S8cRDxkYBb3QJ3+rzNcXZKr47xTkru6Od280OUZdj5BQAAACOwcMpAAAAHIO0fhTwJ93jj6ZxlabHSeUHjxQ/YtHCf6eeH9DSzgiNcfX4nuqp/Ls//1LF4Uzl60jlhw/bl3pj5BQAAACOwcgpAACAjahz6o2HUwdruamNiIicGvylj5b+WdOjTUjOA3Ok+BEr7E7nTzqUq+LZXTIi8p5f/18XFbf+3qGQntt7w5TAqqxY4X6OWEZaHwAAAI7ByCkAAICNSOt7i/mH01VFRkp1ZGr/Olo6Q+q25iou6l+Tzm+zubU69uWgryPeJwSOFD8QvHCm8q//zHgI2NPHWCId6lS+iEi7La1EROTkQCOVz/0c8C3mH04BAACcyi0udoi6DHNOAQAA4BgxP3IaDal8XVH/s7WOWaV+7tpnHF/bs7VpG9iPFD/gHHoqP9xODvym1jHu54BvMf9wCgAA4Fhudoi6HGl9AAAAOAYjpyEyOW+fiuuzV/3I/SdUfKE6XkSsUzxVYkygHravdvpIRGRdz1ZB9yUaePYAF7G/cLg/SPH7trpou4pHpPazsSdwgpmHt6r48Y4D6n2+5/J3qnhap74q/unBQhUv7ppW7/cRMe7n+mKX1T3aqfjuz40NVvSi+vrxRlJt+loglvFwCgAAYCPqnHojrQ8AAADHcImI46fhHszOk0n9ptrdDb/9Nv8zFU/v1MfGnnh78OARFS/o2sHGnuBynhQ/6X0A/uB+Xn+ztz8vXTM7290N2ftVsdz74V9s7cNf2w+XzMxMW/ugY+QUAAAAjsGc0zDQR0utRlEnHspT8UV3IxVX/HsRlIhIeXVTEQndJHj+dW1u/bFdKh6a3FvFoV6IURfPiCmLpBANrLaFXlFk/M6MSg3v70wg9N/x3MpzKn64w6CQnF9fTKUvYBrZvExERO5K6VvrNfXVEO/n7xQbf0+HpzgnK4nQ4+EUAADARo6fXxlhpPUBAADgGIychpnVgqg3uphPwtbTQ9S0iww9la+Ls+HfstRBRTSw2hbaSal8nf47/tqRzSE/v1Vd1LjcatPjCA6p/IaDh1MAAACbuIU6p5cjrQ8AAADHYOTUAcbmFqh4fka6jT1pmOZrW6CO1bZAfbTjQDu6o5DiB0JjzhHjd3xCh/Buczw+N1/FczM6hfW9ECPcwoqoyzByCgAAAMfg4RQAAACOQVrfJuFM/Yz4/KSKWfFvbkmhsWL3/rTwpvlCgRQ/ELxwp/J14Uzl69VcrCoEIDqxIMobI6cAAABwDB5OAQAAbOR22/vhr4kTJ0p+fr6cP39eduzYIYMH152ViI+Pl+eee07y8/OloqJCjhw5Ig8//LDP9yGt7wD3HShScaXb+JGs6J5Yq+2wfd+oeF3PVipeU5yt4rtTMlU8cv8JFa/qnlD/zlqYdXiLiu1e5e6P+9OMPbW9U/yh2Ws7nEjxe7O69hG8FUVbRSR0RfVXFRnXplUB/3CyqsgRKlbp9rXFO0VE5K6Uvj7PMWr/cRX/59XG+fRruorUL2w0atQoeeWVV+SXv/ylbNq0SX75y1/KunXrpEePHlJYWGj6muXLl0taWpqMHz9eDh06JNdcc41ceeWVPt+Lh1MAAADU6fHHH5eFCxfKX/7yFxEReeSRR+TOO++UiRMnylNPPVWrfVZWltxxxx1y7bXXypdffikiIkeOHPHrvUjrAwAA2MYlbre9H77Ex8dL3759ZcOGDV7HN2zYIAMHmmdLf/CDH0h2drY8/vjjUlhYKLm5ufLKK69Is2bNfL4fI6f18OJhI1X1ZMfAUlX6ik49ra+nc87su0JEvNP3ejw057SKrdKZF6rjVayn+Fs1OqfiJq4qFb/RpbOKA9kcwCqVv/7YLqO/FnvY6xZq6bcHwpB+84UUf+SE6mfd0FP5/qTMPWl6Ef9S9aFK53vYkcqfZ5HKf+2I8Tv+cIfQ/I5XuhuZHl9+5hq/z1HhNu7VVte0Pu1r9IFjKr6/hTEloKHvP++ZSiHi33QK1Gjbtq1kZxtTpObOnSvz5s3z+nzjxo2ltLTU63WlpaVyxx13mJ6zU6dOMnjwYLlw4YKMHDlSWrVqJa+99pokJyfLD3/4wzr7w8MpAABAA1ZWViaZmb7/oe++bPWUy+WqdcwjLi5O3G63/OQnP5HTp2sG0x566CHZsGGDJCQkyIkTJ0xfJ0JaHwAAwF5ul70fPpSVlcmlS5ckMdF7oXZCQkKt0VSPkpISKS4uVg+mIiL79+8XEZH27dvX+X4NcuQ0VCtHA03lW1naLdWIJbXW52/Zc17FH19vrHKr0FL2ehudnm6Kc1er2Fea3t82vhRUng2ovR2p/GhI3/sj2lL8dvys7aKnGqul5vcwVNMR/LmHhTpNHw3GWVxfoUrl65Z3SzY9Xh3A+E+122h7176vTdtYTR9o6Kl8Han88KisrJSdO3dKVlaWrFy5Uh3PysqSVatWmb5m8+bN8sMf/lCaNWsm587VTCXMyMgQEd8Loxg5BQAAsIvNNU79rXM6c+ZMeeCBB2Ts2LHSrVs3mTVrliQnJ8ucOXNERGTRokWyaNEi1X7ZsmXy5ZdfyoIFC6RHjx4ycOBAeeWVV+R//ud/5OTJk1ZvIyINdOQUAAAA/luxYoW0adNGnnnmGUlKSpKcnBwZPny4HD16VERqp+rPnTsnd9xxh7z22muSnZ0tX3/9tfzv//6vTJ061ed7uUQkgL0B7HEwO08m9fP9xTRkVql/K3qFAH1aQTgFunIfoRENKX4glo343BglWt2jnWkbPZW/tmdrn+fUi/abbdgC32Zvf166Znb23TDM9pQdk3s2LLC1Dyu6fNevBVGRwsgpAACAnRw/TBhZzDkFAACAYzByGiP8SeXrIpXK15HKt0e0reIHYo1VKl/nTypfRyo/drhF/NqlqSFh5BQAAACOwcMpAAAAHIO0fhj8rsDYn/bZ9OBXvw3NqdlVYX2vq+vdJ0CEFD8QqN98sUfFf7j2eht7gpjGgigvjJwCAADAMXg4BQAAgGNEdVp/ddF2FY9I7WdjT7zVJ5WvCySd3/df1abHd95o/PvDqlD/3Z9/qeI1PdoE0sWgzTu6ScVWe2AjvCKV4n8sb7+KX+7cPaTnbkicdL9zUl/CLVKp/Dtyzpgef69XC9PjetH+Fo2Me/vybsmh7ZhN3in+TMXDU/rY2JPIYLW+N0ZOAQAA4BhRPXIKAAAQ1dzCgqjLuCQKviUHs/NkUr+pdnfDNv13V6p42w3xPtv32mkMiOf0NU/3R8ofCz5V8a/TbzZtQ4rfWUKR4n/w4BEVL+jaod59AmJFoPfzQNvDf7O3Py9dMzvb3Q3ZffKY3P3OIlv7sLLHHZKZGZopiaFAWh8AAACOQVofAADAViyI0vFw6jBrio0C/nen1Ayx+5PK6brDaJPTt9K0zYqirSoelTpAxbftPafiD65r5n9nLTydv0vFVql8Hal8ZwnFKn67UvlLCjeLiMj9aYNsef9YY3XPiGavHdms4ipthfSjHQeG/L08VQ30igZW9/Pe/zI/hz/3f33l/tqerQPooW8LtWlXD3CvRoSQ1gcAAIBjMHIKAABgJ8cvTY8sVus72NCc0yLiXzH+6z8z0lN7+pj/SDN3Vam4RaMKFYcilY/Y50nxh7pIP+A0U77Yq+IXrr2u3ufTC+xbFdXX1WeF/sj9J1S8qntCQK9taBy1Wv//Ftvah5U9b3fUan1GTgEAAOzk+GHCyOLhVOOELfnG5haoeH5Gep1t9e1IK92NVDxwt9Fmyw1NVJzd22gzbJ/xL3M7ti+NBp7FNSIssBExRkzDsdUpdVERKfO1BT5jLRb4hGK0VMS4t/pzX7X6+xPo3yVGSxELWBAFAAAAx2DkFAAAwDYuETd1TnU8nGrsSuXrGgUw8eTj668M6Nz+pIdGHzim4uXdkgM6v1N56vQFWqOPVL65UNRBvRypfERKJDd0bhTAu1ndk62Om9XEBmIFD6cAAAA2crMgygtzTgEAAOAYjJzaRN/i8/edeqt4bkanWm099U5FRCqqjZp3elp/4O6LKtZX6Ov8mbagp/LXFu9U8V0pfX2+1qnM0vn6SvyERkad16HJvWu1hbVwpPjDyZ+V2og9kfy5D9v3jYpX92gnIt73cKu61fq0q1lfGdUCrKZvkcpHLOPhFAAAwC5uoc7pZUjrAwAAwDHYvjQG+ZPi11NP63q2CnufED1CURA/GlL8QDTQN1uxgafiPgAAIABJREFUSvGP+Pykij1TCepjzhFjGsSEDrE7/cUx25eeKJHvr7F3+9JVN9zG9qUAAAD4N+qceiGtDwAAAMdg5NQBxufmq1hfre9J1QSapqkW419geoo/3lWlYj2Vf9e+r1W8tmdrn+cfm1ug4vkZ6QH1zWOptlr+vnoUu1+orcINtMi+h75yv6EW3n8sb7+KX+7cvd7ni7ZV/IhtVqv1Xzti/O4/3CE0v/v6lCnPPXdNjzY+X2e1SYqeytdT/PFxl1RcFeJxplhO5TuVy/ETLCOLkVMAAAA4Bg+nAAAAcAzS+jb5zRd7VPyHa69XcShWSuusVuvr4l2XfLbRBZvK19Unla8LNpWvq7LYNy4UUwaiRShS+VZI8YdXrGyWEU6V2q/4n7WV6L8MUfraamrUmuLsmv8X32l9q01ShuypULE/q/VDIZpX60ft7wNpfS+MnAIAAMAxGDkFAACwE6WkvPBwapNQp/L7/qtaxdtuiFdx5i5jhX5270amrw1F0eZYFG2p/GiYhkCKP/SiKnVpEz01PevwlpCfX0/l37b3nIrvTgmuqLleZeWT669QsZ7i14+H+h4ebal8Hb8PsYG0PgAAAByDkVMAAAC7uIUFUZfh4VRj1yq/YFP5/XdXWnzGGBC3SuUHWng/ljk1BR6oSH0doaooQYof7xR/puLhKX0i8p6PdhwY1vN/cF2zoF6np+ytjuup/Dtyzqj4vV4tgnrPaGa1aQFiA2l9AAAAOAYjpwAAAHYire+Fh1ON01b5efZovlBtrL7XU0b6qnydvnJ/543G4Li+ArShp/KdIFrTUqHYHOJyVin+B2//SMV6ShOxIVKpfH9M+WKvil+49rqQnltfwV+h3c/1TVKsrm+r6VvV7oad+IymeyYCx8MpAACAnRg59dKw/+kFAAAAR2Hk1MHW9WwlIkZ6318zrtmj4qHSW8V6Cgn2Iy1lTk/lL3j/VhV3luBW8U86lKvi2V0ygu0WYlyoU/k6fTqWnuIXMb8n620ebr1PxSPEuGcEWxUAiAY8nAIAANiJ7Uu9kNYHAACAYzByGgU86X1/DU3u7bsR4FD6qmU9lR9soX5S+XASf9LxepsPhOk/aHh4OAUAALCRi9X6XkjrAwAAwDEYOY1iQ3NOq3h9r6uDPk+o9koHwsmqUH8gKX40TH8+sknFv+ww2MaeWNOrsgQ6leunBwtVvLhrWsj6hAhxC3VOL8PIKQAAAByDh1MAAAA4Bml9m1jt43zfgSIVL+2WWuc59FT+HTlnVPxerxY+33/0gWMqJpVveKtwi4p/nDbQxp74Z01xtorvTsm0sSeRRYrfsLpou4pDtbGD55z6+aL5WqsSo4bkrMPG7/ijHUP/Oz7i85MqjndViYjIiu6JPl+np/L9SfGP2n9cxQ0llR+Oax3OxMgpAAAAHIORUwAAAJu4hFJSl3NJFKwRO5idJ5P6TbW7GxGxtninilecTRAR65SNnj5a3aNdQOe+K6VvsF30aeFRY2XsA+2duTIW/llSuFnF96cNsrEn/vGk+O1K70fb96sh0lfun3Mb4zNPduxv1rxePPfccNxvx+YWqHh+RnrIz+/hzzUdren22dufl66Zne3uhuw5XiL3/G2prX1YMfAWycx0znQd0voAAABwDNL6YTbz8FYVP95xgM/268qNxUy+Jrnro6X6Aifd8m7JKg7naKlOHy1dUWR8/aNSfX/9kRrdtRLNiz7CIdpG/zwjpnYtkrL6fgXye8A1GF5NjbVR8ssO5qOlvyswfgbPpgf/M9Dv54GwGhXVa1LXZ7T0t/mfqXh6pz51ttWvaasR0kiNlsb074bb5btNA8LIKQAAAByDh1MAAAA4BguiokCgqe5A2z+Wt1/F8a5LKtbrrwJ2mHQoV8Wzu2QEdY6GXgcVzuLPQia9jc6q/eS8fSp+qXNPFT+dv0vFv+/UO6B+NgSOWhC1fJmtfVgx+NssiAIAAADMsCAKAADATo7PYUcWD6dRwJ/U/E8PFgbUXvdy5+6mx5/LN6YHTOsU+ZXziC7ztfq2Y0NU3zbYVL6OrU7hJP6ssr/CValif34H9FS+jlQ+ohVpfQAAADgGI6cAAAB2cbN96eV4OHUAq5WWgfBVsD+Y9ySVj0CEKpUfTqT4G6ZIbqkcivt5oNNZmIKFWMPDKQAAgJ0YOfXCnFMAAAA4BiOnDmBVNLmiOr7W58PxnkBDRIq/4dBT+f6k+P9Y8KmKf51+c0DvdUVcZa1j4S6GTyofsYaHUwAAADuR1vdCWh8AAACOwcipTX5XkK3iZ9ON/Wx9pXzG5+areG5GJ9M2/uzdDMOaYuNncXeKc/YWRuSQ4g+NtcXGqvFANwMJp/kBrtYPNJWvK69uWutYfVL5j+QdUPGrnbsFfR4gmvBwCgAAYCPqnHojrQ8AAADHcEkUTMM9mJ0nk/pNtbsbABoYUvxA7Jq9/XnpmtnZ7m7InpLjMmLxMlv78NZtQyQz0znT2hg5BQAAgGPwcAoAAADHYEEUAFhgFT+AsHNLFEywjCy/Rk6HDBkib7/9thQVFYnb7ZYxY8bUajNt2jQpLi6W8vJy+fDDD6VHjx5en2/VqpUsXrxYvvnmG/nmm29k8eLF0rJly9B8FQAAAIgJfj2cNm/eXHJycuRXv/qVlJeX1/r8lClTZPLkyfLwww9LZmamnDhxQjZu3CjNmzdXbZYtWyZ9+vSRYcOGyZ133il9+vSRJUuWhO4rAQAAQNTzK62/bt06WbdunYiILFy4sNbnH330UXn++efl73//u4iIjBkzRk6cOCE/+clPZO7cudKtWzcZNmyYDBo0SLZu3SoiIr/4xS9k06ZNkpGRIbm5uSH6chqWx/L2q/jlzt1N20zO26filzr3DHufgFhFih/h5M/93J82iE7UOfVW7wVR6enpkpSUJBs2bFDHKioq5J///KcMHDhQREQGDBggZ86ckS1btqg2mzdvlrNnz6o2AAAAQL0XRCUmJoqISGlpqdfx0tJSSUlJUW1OnjxZ67UnTpxQr7/cuHHjZPz48SIi0rLd1fXtJgAAgDMxcuolZKv13W7v76zL5fI6dvnnzdro5s2bJ/PmzRORmiL8DdnT+btUrO/R7E9ah1Q+EHqk+BEsq9S8P/dzUvloKOqd1j9+/LiISK0R0ISEBDWaevz4cUlISKj12nbt2tUacQUAAEDDVe+H04KCAikpKZGsrCx1rGnTpjJkyBA1x3Tr1q3SokULGTBggGozYMAAad68udc8VAAAgIbG5bb3w2n8Sus3a9ZMOneu2X82Li5O2rdvLzfccIN89dVXUlhYKLNmzZKnn35aDhw4ILm5ufLMM8/I2bNnZdmymr1iDxw4IOvWrZM333xTxo0bJy6XS9588035xz/+Ua+V+u8Uf6bi4Sl9gj6Pk/yx4FMV/zr9ZhHxTuXrnsvfqeJpnfr6PPeMgu0qfiq9X7BdBBxrSeFmERG5P21QxN6TFH/0mn90k4rHth8c8vP/Nr/mb9T0Tsbfp1Cl5l88bFxfT3bsX0fL8Ft/zJh6NjTZ/O8VEAi/Rk5vuukm2bVrl+zatUuuuuoqmT59uuzatUumT58uIiIvvPCCzJw5U2bPni07duyQpKQk+e53vytnz55V57jvvvtk9+7dsmHDBlm/fr3s3r1b7r///vB8VQAAANHCbfOHw/g1cvrxxx+Ly+Wqs81zzz0nzz33nOXnv/76ax5GAQAAUCeXOPKZ2dvB7DyZ1G+q3d0AAL+R4gecbfb256VrZme7uyF7jh2Xkf+9zNY+LBs6RDIzM23tgy5kpaQAAAAQIIem1u1U79X6AAAAQKjE5MjpmuJsFd+d4pxh6nCanLdPxbdfeUHFdlcxcFJFhdVFRrWCEamxXa1gbbFRyeGuFN+VHGLNiqKtKh6VOqCOluET7Cp+q003EDmzDhslDh/tGNgW2/q9ONhNUPRC/VlXnlex3ffQtwqN78uP03x/X+YcMaohTOhgXg1h5mHjd/XxjnX/rr52ZLOKH+4QuYociLyYfDgFAACIBi5xZq1RO5HWBwAAgGOwWj/KTDyUZ3r8jS6BrTic8sVeFb9w7XX16hOcpyFObYkWnhQ/K/ihs5qKo9/z9ft8KKYPRJITC/U7ZbX+3uLjMnK+vav1lw5z1mp9Rk4BAADgGMw5jQJW/3KuD0ZLYxujpc7lGTGlDmrDNDa3QMXzM9JVbLVw8aK7kenxaBgt1QU6Wmq2lTcaDh5OAQAA7OT4CZaRRVofAAAAjsHIqU1+V2AsWHk2ve4UbH1S+VYpJBgaUv1TOEewdVBRP0sKjVqZ96eFvlbmpEO5Kp7dJaPW5wO9D+vtHzx4RMULunYIonfRQ0/le/5e+vpbGc0oJeWNkVMAAAA4Bg+nAAAAcAzS+jYJdXpi9IFjKl7eLVnFdqfyo6HeJqn82OO0687XlqSk+CPHn1R+fbYvNUvlB2rU/uMqXtE9UcV2p/LDPSXCiufvZUxv7Uta3wsjpwAAAHAMHk4BAADgGGxfGuOs0kMAnI8UP3Tczw2/+WKPiv9w7fVBncMx25cWHZd759q7felfv8/2pQAAAIApFkQBAADYiDqn3qL64XT9MWPlXqD79jpVsEXzR3x+UsWre7RTsZ760Vf0XxV3Iaj3iUYriraKiMio1AFBvS6Y10YbNiJwJqeu4p93dJOKx7UfbGNPAhfJvt93oEhERJZ2Sw3odf7cz9cW71TxXSl9g+2iY71T/JmKh6f0qfV5PZXvqy2iD2l9AAAAOEZUj5wCAABEPdL6XqL64TRWUvmP5e1X8cudu6vYs4+yP4WXH2x5WMWrpZ1pmytclSqO9VS+LtiUfKyn8nWk8p3PSSn+cKfDVxUZX9PI1P51tPSP9xSw8Pb9pwcLVby4a5qIiIzcf0IdW9U9wec5/LmfrzrbNsgeRgc9Pe8pvm9VeH/zBZLAsYafKAAAABwjqkdOAQAAoh2r9b3xcFoPC7VVnw/UI8110d1IxZ5UvohIhTu+Vtu7P//S9Bz6/uF6mzU92tR5vrpMOpSr4lDsF+1US7X9ou+L4H7RoRbqVGg4hGOFcUOsNOCkFH84hPr6Lbp0VsXhXq1fqd3PPRVSlndLNm17176vTY/r93O9zdqerVUc6P08mnnS+Var8vV0fyiK88N+PJwCAADYiZFTL8w5BQAAgGO4JAqe1w9m58mkflPt7objWBVqtkrr64It9g/AuWIxxd9QWE3Z0lndz3WxfG//bb6R1p/eKbBi+2avnb39eema2Tk0nauHvUXHZdSfl9nah8UjhkhmZqbvhhHCyCkAAIBd3A748NPEiRMlPz9fzp8/Lzt27JDBg/2btz1o0CCprKyUvXv3+tWeh1MAAADUadSoUfLKK6/IjBkz5MYbb5QtW7bIunXrJC0trc7XtWrVShYvXizvv/++3+9FWj8KBFrAWWeV+o+Utwq3qPjHaQMj/v5AQ1WfFH+we8LDN3+mXYXjtaHg1MoYvyvIVvGz6eapabM2jknrFx6XH822N62/aKTvtP62bdtkz549Mn78eHUsNzdXVq5cKU899ZTl61atWiW7d+8Wl8sl9957r1x33XU++8PIKQAAQAPWtm1byc7OVh/jxo3z+nx8fLz07dtXNmzY4HV8w4YNMnCg9cDTxIkTJTExUf7rv/4roP5QSgoAAKABKysrq3PktG3bttK4cWMpLS31Ol5aWip33HGH6Wt69eol06ZNk/79+0t1dXVA/eHh1AHG5+ar+Fx1ExV7UmqBpvJ1Vns068X+F3TtEPT5fYmGVH6oNlOw24qirSoelTrAxp7ACepTqD/W0vlzjhi/4xM6hP53PJCpV/VJx/+8pfG3Yo0Y54nU/dxJqXydnspff2yXiocm9zZt40iOn2BZw+327qjL5ap1TESkSZMm8tZbb8kTTzwhhw8fDvh9eDgFAACApbKyMrl06ZIkJiZ6HU9ISKg1mioikpSUJD179pQFCxbIggULREQkLi5O4uLipLKyUoYPHy4bN260fD/mnAIAAMBSZWWl7Ny5U7KysryOZ2VlyZYtW2q1Ly4ull69eknv3r3Vx5w5c+TQoUPSu3dv09foGtTIqWfvcaftOz43o5OK9fSMhz8rNIft+0bF63q2Ml6b4vBUhgNEcypfRyofVuqT4o8Feir/z1qK/6LbGJ95tGPwU5CsUvme+7lVqv2ufV+reG3P1j6P6/fz0QeOqTicqXydU1fr6/RUvj+r+B0jCtL6M2fOlCVLlsj27dtl8+bNMmHCBElOTpY5c+aIiMiiRYtERGTMmDFy6dIl2bdvn9frT5w4IRcuXKh13EyDejgFAABA4FasWCFt2rSRZ555RpKSkiQnJ0eGDx8uR48eFRGR9u3bh+y9eDgFAACwiUtEXFEwcir/v707D5Oiuvc//u1hEUE0iYgIDAwwbAFRnAxBRI0JXIy4YiQa90tQkMQ17lEDRNG4gV7EB2LCIjF4Ra5LIBDUmAgaBgxBkG0YtmEH/Sk7DFO/P8auc3qmarqqu7rrVM/79TzzPIeamu5DT3VTnM/5niMiEyZMkAkTJjh+74ILLqj1Z0eOHCkjR4709Dx16ubUtDjfiR7PxON8L9WdB44dl/Lz5IpXtKr7ITkS1QNBq+sR/20ZqNZ3E/+cdZuapUf2ukNW8n+aX+vSMs3e+WdqlO9Gj/KfWL+oxvdbtdifze7ABwqiAAAAYIw6NXIKAABgFEsiURCVTdycGiC+j7VI4uLXfhZr/rDH8YH2KYpSjfKZDoC6qi5G/C9uXGC3f9n2nMAff/DK7Xb79a5Va0L6XXh/fvemgfYJIg+1qzklYfyiJiH0BF5wcwoAABCiqBREZQtzTgEAAGAMRk4NkGwfa7cFmfst3+t4vlsk5Gf/56BM36witGvzVYRm0j7wQUX5k7XpAdla2N+k1zEsUVgYPAxu04XcOEX8uRjvZyLK18WjfDf6himV2iYAc7ufaLcHLP/a8bhOX4Q/W5X7b29Ri9pHbYOXsRtq7kiUf+q+EHoCL7g5BQAACBOxfoKYROAlWV1SKiN6PRB2N4zmZYtTN7eXrrLbLxR2CaxPiD5GZuu2ulIkZZorPt9lt2d995Sk5w9fW2q3J3QszEifctH4RU9K5+LwX6/lm7bL1WP/FGof/njNuVJcbM5oOHNOAQAAYAxifQAAgDAZn2FnFzenIXlw3TK7PaZDj7Qfr0neYbvtd6J8AzmW9vNnUyYLj6ZpBVzX52e2cCIKohDlR7lIw3S5sg6qW2FmJoxYu8Zuj+/Yqcb3vRSqNco7are9fJ43iFX47idgMm5OAQAAQhQLuwOGYc4pAAAAjBHpkdN3tyyx2xe3KsrY82RiHcW8WKXj8btKV9rt5wu71voYN6/e6Hj8j53b+urLs4XdfJ0ftlyO8meWq7j0yta9azkzWFFeK7SuRPmTtOksQ0PYZjdXIv5MTAtyi/Ljn+f6Z7mXNWcbxVSs7+XzPBdXWXH6PYWxljTCEembUwAAgMijICoBsT4AAACMwSL8ddQ9pSvsdtRifQDmiHLEnyv4PE+NSYvwX/NcuIvw/+FasxbhJ9YHAAAIiyUSM36YMLuI9QEAAGAMRk5Doi/Cf8SqZ7fraVX8h6wGIpJYialX6Putytfp0c/DZUvt9uPtz0z5MaNEr9BvXq+J3R7QMty/P3vZhy9bq4DkiihU8c/dqj7jMv0ed3out2r+oD7P67ms/oIIYeQ0ASOnAAAAMAY3pwAAADAG1foR4GdhfpNFeaF3AP6YGvGHzS3iR/YZU62/cbv87Jlwq/VfucGsan1GTgEAAGAMCqIAAABCxFJSibg5jQA9yh++ttRuT+joL44Ie6FmovzgzSxXcemVrXvXciaQXVGo4g+DW5Tv97NdX/FlTIce6XcMMAixPgAAAIzByCkAAECYiPUTcHMaMX6jfB17LuceonxEARF/cn4/24nykcuI9QEAAGAMRk4BAABCErOo1q+Om9McoS/srGORZ0TB7C2f2u2LWp0VYk+QaUT8yd1eusrx+AuFXbLcEyAc3JwCAACEiZHTBMw5BQAAgDEYOc0RxPeIMqL8uomI3xnxPeo6bk4BAABCREFUImJ9AAAAGIORU4MVLz0mIiIlZ9YL5PHuKV1ht/UF+Z9Yv8huP9SuVyDPFbTXyz+224Nbnx1iT7zRV09gygWCNrNcxd65shFD2BF/0382s9t7z90d6GP3/s9Ru/3JGQ0CecyHy5ba7UYx9fiPtCsO5PGRZYycJmDkFAAAAMbg5hQAAADGINYPyHEftrDbh8/fnvLjHPlbW7tdcubGGt//arbaf/mki0p9PfbiA+0dj5sa5euiEOXrvET5z21QUxXuLojW3w/hypUo300mI/59f1WfgydcWGa3g47yRUQq5rcREZFPztiU9Nz9Wr+aaP3SVb6Xb7cfd/44R1QR6ydg5BQAAADG4OYUAAAAxiDWD0g6Ub6uYf+aUb7Ob5Sv+7DH8Sn/LIJHlA8kF3TEf4JLZJ4J9fslj/Pj3KJ8Xd6PNqfTHZjKYp3T6hg5BQAAgDEYOQUAAAgTI6cJuDk1zBfvqirvimNVA9vNL1uV0efUF3N+vP2ZGX0uU1y84ku7/W63b4fYEwBeOUX82Vqk36s1L6vVTzoNq9rgZOdbXexjmf48f2r9v+z2/e2+n9HnAjKFWB8AAADGYOTUMN+5eE3ykwJWV0ZLdYyWAtEWHzENY6vT2sRHS3WZHi3VMVoaRZbELHJ9HSOnAAAAMAY3pwAAADAGsX5Itv9fV7vd4vKVKT3Gpv893W63ueozx3PSmYj/aNmndntU+7N89g4AMi+TW51m2uY3utvt/J8sT3r+7ndUwWyzS7I/BQwZRKqfgJFTAAAAGIORUwAAgBCxQ1Qibk5Dokf5W97sZrcrK2N2Ox7zbHxdxfdtB6v43i3K16VTJZrLUf6A5V/b7WOiXvP53ZuG0Z1ATNr0kd0e2qZviD0BwuEl4l/3J7U6SYefqTWe07FxZB+73faxhXZ77eQiERHpeNMS9fzTe6rn/8m/fT0PUT7qCmJ9AAAAGIORUwAAgLBYQkFUNXX+5nT65gV2+9r8cwJ5TC8V8nO36nGSag9oqSKneJyvR/nrXzvDbre75j/q+J97qONXL/PV3yC2L31xo3odf9k2+euYidfdj7ndT1Rt7XdR+VlHu/3+6U2y2qfqfdGvhZc3qsh+WFsV2b+iRflDQo7y3fqiHz+qfQDrfw+/XtJeD31ahpdrL26y1q+bXPob9mvqRr9Oyiv22W23/rpdP37o71md/v51u37D4Brx/8xfFf/mR1Rknz96oePxVUNfUj8wVDX/cqDq8/+XU39mH+t4rVoFxY3bVC43d5WqaWLPF3at5Uxv/F4vf96sXper8/vUcmZ63P7d8HJtIlrq/M0pAABAWGJCQVR1zDkFAACAMWISgZkOq0tKZUSvB1L6Wafhfr9D/SPLVKXlY+2LHM8pn6kq7ltfucJuuy2yrD9m70b1HB8zWSxWOk1VfRZer6o+S1/Vjl+njn97wXfs9pSCuXb70lbFtT6PX3rE30j772A6FeTpxJJF/64UEZElPfNqHBMReeJUNQ1iX+Uhu31CXiO7nU5E2eNTFTsvO0u9Hk7Xlf7a6bzE1X6nVnjh9Jh67F2pnevl96vH8Ucs9fu4syD1KHDsBhUpNoxV9eg49ZJ7iubdIv5smaZ9Tl3v8vnkthqD31Ua9N/Bbdp7yc/1k83Xa99f29vtEy4s8/xzblX5QS3Uv+V+52t2+R0v1TiWzueHl9UFhq8ttdsTOhYmfczR60vs9iPtav/816+vxjH1xsp0ZK5fY06CuO7GL3pSOhcnf70y7fOybXLjyD+F2oeXfnGeFBcHey+QDmJ9AACAMBk/TJhdxPoAAAAwRs7H+lGjV7t2mDFMRNyjp9Lnejse11U2VsFrp2GL0uxdtB33YQu7ffj87YGfn4v0yDzV6D0T0w3cPL2h6r1yb0Hy90YmRKHSP4jfaa4IKuJ3E/889xvrr3tW9Uub/ZKRPgYh7GkxqTIq1v9NyLH+L4n1AQAA8A2q9RMR6wMAAMAYxPoGSzUSQvi+/ItazP/bA9c6nnPD6s12e2rn/Iz3KSruW6cWHf9dh9NrORO5quk/m9ntvefuzspzZjLiN2lzAijGxPrrtslNj4Ub64+/w6xYn5FTAAAAGIObUwAAABiDgijD6Isj76s85vnndv5CVd02/5+FtZxZpWJ+G7tdv98mz8/j11Pr/2W372/3/Yw9TyZ8NVvFPSddVFrLmTW5Rfm6qEX58bg901F7EI/vZ5Fxkcxfp34q5Kmmz16Ur9OjfC8Rv3WOiudjC1Rsf+RCdb394oUZIiLy5bEDvvqya/jZdvuUCR8nPb/lJ03t9tbee309lx/pbIYShFx+b1AQlYiRUwAAABiDkVMAAIAwWQyd6qjWz4Bdw7RI5mXnSGbPUHXOyZOcz7mndIWIiDxb2C3A3qG63e90stvNLlkTYk+y68F1y+z2mA49QuwJkFmbH1ERcP7o5NOedH6r+CvP72m38z78t6/nQnaZVK1/8yPTQ+3D/9x1PtX6AAAAgBNifQAAgBBREJWIm9M0rB+jovl2D6po3i3K17lF+bpHRv5cRES+JcnPdbNniDZ94BXnx4m938puWz/ckvJzperhMlXp+nj77C9QXZeifB1RPuoKv1G+zm8Vvx7lHx5YFZMe95cSx3PTUf6gmqpwqNtB1a/rmEqA6CPWBwAAgDEYOQUAAAgTsX4Cbk7ToEf56dh3lVr0e89VarHmtoNrf/z9V6qfazLzX47nuEX5ujCifF0YUb5u2/91tdunXb7Sbm+d9V273fKKz7PaJwDB0av1846o462eco773RbY9xvxF41aIiIiy//ir79etB6T+lQFwHTcnAIAAITFEolVht0JszDnFAAAAMZg5DQkL25cYLdb11tkt6/YgpriAAAgAElEQVRo3cvzYzTceyzpOfFqUZHMVIzGXblyp92e2bV5xp4nHW4x/bJer9ntAXKm4znZcsPqzXZ7aud8X+cfterZ7de6tAy2YwG5eMWXdvvdbt8OsSd1S9DvzxFr1QoX4zt2quXM8GwcqaL8VUNfstvdx92W9Gf1KN+Nl4h/+Yju37TUhhc6fcF+Kxaz2/X+/qnj+Uf/63t2u8G8xUn7mKr4BjAiZm0C42XjEDYXyQ3cnAIAAISJgqgExPoAAAAwRp0fOc3EAvA7bldx0qkvOFdUdmrQxPH47C0qzvmvG4aKiEj995bYxyp+WGS3vcQ6eUeT/3ds02Oqv21GplYB6jcqvHn1Rrv9x85tk57/4xX/z27P6fYtX8/11eyqvZNbXqRi+n1/ba+doa6Bd7eo1/q8ZYPt9ok/XufrOVNVT5xnxd+ypsxuT+yk+u4l+s8Wt9+RflyP8n/42X67/f7pzu8HL674fJfdnvXdUzz/nB5dNso7arcPVB5nt58v7CpBSBaT+o3J/U7n8PL+HLxyu91+vWuLlPo4d6t6Lw1omdlVONa8XDUFqtOwRY7fb/uY9lk2VDWX36Ei/gFPOffxyIVqOlT9gxV2W19gX5c04u+txcufqNjZ7fHc5B11/nzYOUJ9hjcfn34Vv98of2SZ+tx8rH1RLWfWdHvpKrv9QmEXx3PuW/eZiHiL6Ynyc0OdvzkFAAAIS0zYvrQ6Yn0AAAAYIyYRmIa7uqRURvR6QET8x/D6+X5+Tuelgrrsd2oP+/b3qYXvO5Q0stvrig/Z7a+uU9HPh0+9aLePizWo8djt37zVbnf8hVpsf+2LahH+jr90XoT/aD8VsWy8SUVCzeaqfn1rWvqbCQxY/rXd/k79fXb72qbb7PbFrZzjHj3iP6JFlNO7tE7+xO9p5/yo3PO5x9VXUd2swtl2+5I1F9vt2Z3V8XQiylMWqoh7Vx8VcTtVUOvTCmbt/47dfqVTO8fH1s9/be+pdrtS+39nOpX7s8prriRx6ed77GP6NAS3SF0//+cnqekJl7YqdjrdNz2OvuHEqg0l5hxoah/LZjX5o2VqWs6o9mcF+tjXrlLXt/7euGbVVrvt5Xftd0qNk7tK1WYVQU19cFMxv43drt9vk+efWztZfd682He63R7Y+JDT6QnvcbdpNPrqJ/EF9kX0qnxJiO3jEb/bIv3pOHyRthLLbH8rsawdp/796XhH7X0bvV49dpOY+ty8u0D9m/fUevXvz/3t1L9L6XC6xoK+7sYvelI6Fxem/TjpWlm6TYbc/2qofRj3wA+kuDiYz+QgMHIKAAAAY0Ru5FQXxlp7Df5+mt0++oNttZxZk5dJ6/o6du9P/r2IiBROH24f63BvMFumetn6NGiZXgtVL3I64UI18nHkb1WjQw37qxGjSZs+sttD2/RVD+JnJLYWx3+oRjEPnr/D8ZxUC3n8Cup5+i3fKyIi87s3dfy+Pno+t/uJKT9PUIVSfmSiMDKTgnov6aPab3/35LT6JBLcZ3Lv/6gCtU/OqJkmiYjsfKuqeKb5Zascv69bO1WNYne8wXkNUb2Y68tjahvpq/P7OJ3uzqH4yW0d1FiRVnikrXOqt62SzxyfpuJHamRYL5rNRfGRbH0UO9XH0B+HkVPFtJFTCqIAAADCYlEQVR2xPgAAAIwR6Vjfr3jxiFthjpug4spU6XHThQOvtdvWv1c4ne7bvqtUxH/C/wYb8U/frLZpnfrV6XZbfx3f3qIm3HspkonH9CIihyrU4H/ga5F6iPhdpwdoTl6g1vbcc86XjueYxEukmkl9/nPEbuvrj6Ya8Q9Zs95uuxWWpSPVIo1M9yudyD6+Nq2+Xq1bQZabsLc4XTddbQ3a4Vp/64lmklvE7yavu7b2Zz0V91f+R1132drWNJvr2CZ7f/h9/zidb0ysv3ab/Py+cGP9sQ+ZFeszcgoAAABjeLo5Pffcc+Wtt96S8vJysSxLbrzxxoTv//GPfxTLshK+Pv44sXCnYcOG8sILL8iuXbtk37598tZbb0mrVq2C+5sAAAAg8jwVRJ1wwgmyfPlymTp1qkydOtXxnL/97W9y/fXX238+cuRIwvfHjh0rl112mVxzzTWyZ88eee655+Tdd9+VoqIiqax03pItaDP3NatxzMsam5mI8r+8Sa0R9+3JzhX4ledXxVLzDqj4/r9nvGu3B5/wld12i1j0alBrifM0AD3K/+paFTlZeSpCSnUt1Gvzz3E8rk+V8LvepV51f2hOB88/99JGFcEPK73Gbuf9aLPT6Z6q9d2ifJ1blB90pXRQwojydQvPaKj9qaHreV5lIjLXpbreYlD9uniFur707WHdrim383WVVs1xCy9Rvv55GkaUv/kNtd5oh59kL8qPf1aLOG9Jqn8OJ93qtPpjL1erEeT1cN7eM3ZMzc47dEkvu93oHeetXXWbH65ajSD/8eTbnr69v3HSc4KS7P3h5f3jtl5t/Hiz1odT7F3wKIhK5OnmdM6cOTJnzhwREZk8ebLjOYcPH5YdO5yXzDnxxBNlyJAhcvPNN8v8+fNFROT666+XjRs3Sr9+/WTevHkpdB0AAAC5JrA5p3379pUdO3bI6tWrZeLEiXLKKWo9xaKiImnYsGHCTWh5ebmsXLlS+vRxXkNu6NChUlJSIiUlJXLSKdkvQgIAAED2BbLO6V//+ld58803Zf369VJQUCC//e1v5f3335eioiI5cuSItGjRQioqKmT37t0JP7djxw5p0aKF42NOmjRJJk2aJCJV1fpBcNqqTz+mb1PqxfrXzrDb7a75j+M5m3+tbr7zf6tiE7coX2d9sxDzM9f/zD72zhu/185Q8Wvle2pb1YSYWlvMubKviv7zPlJVlweuUNX6J01X0dIX72qx3DTV3Hqf+ju1/F3yKChOj/KD4qdC/7a2KoLPe09lKK6vnYt0NmLQI9Ugonx9685DlnY9OMSyIu4xbnyBfZHERfbP1BLKpd8kl05bmqZyXHfuMrWl5D97NHI8RxevJhdJrCjPlnS2UUx11RAvvEwVcbsGdKlOZXLbDnX4WvUZPqGjv+ro/drmGk20zTWc5P9kua/HDoqlL6DvxOX7fiP+BL1OdzzsJcrXeYnz49KZqnFPqZpW9mxht1rOdOcW07txOyd+/IxFx6XUj4ywyPV1gdyczpgxw24vX75clixZIhs3bpSBAwfKrFmzXH8uFouJxS8EAAAA38jIUlLbtm2T8vJy6dixo4iIbN++XerXry/NmiUWJDVv3tx1nioAAEBdELPC/TJNRrYvPfnkk6VVq1aybVtV5LlkyRI5cuSI9O/fX1577TUREWnVqpV07dpVFi70HimIJA7r67wM8Sfbn3dq53zH427conydHuW72f8TbZ/7N7RF8B2SIL2yPdZTRSN/+8t0uz3gvYvttvUjLebq67JosksilTfDORb0E+V/e8F37Pbc7s7n+K1ar5jfxm7X77fJbn81W8WFJ12UZCqIVomv/w/tZb2iX5sGEHtfLXt29AdbkvbRjR6pBlGtf92JahqCfm14qcj2K744v1s0P/YL55jR7Xx9sX03P/xsv93WF+HXo3yniF9fcFvXKKYW9U8novQb5evTAJLF+fpUjde7qmlPV3y+y27ffNIGu63/3vVryo1+bRyy1D8B+nSO+BScxnmqmlnfEEF/Hd2ifJ1blH97qapEf6HQuRI9WZTvxcbX1bXZdrDaq37dsypK73CPitJ3DVerqZwyIfkUrHp//7T2E5LF/uIt4q9ctkqcZGsf8nSmZ/iN8v1E+F7Odbp3MKlaH4k8XdNNmjSRwsKqCzEvL0/atGkjZ5xxhnzxxRfyxRdfyG9+8xuZOXOmbNu2TQoKCmTMmDGyc+dOO9L/+uuv5ZVXXpGnn35adu7caS8ltWzZMrt6HwAAAPAU63/ve9+TpUuXytKlS6Vx48YyatQoWbp0qYwaNUqOHTsmp59+urz11luyZs0amTJliqxevVrOPvts2bdvn/0Yd911l7z55psyY8YMWbBggezbt08uueSSrK1xCgAAYBzLgC/DxMTIbiVaXVIqI3o94Pn8eDWsSGYqYv3Y/IhWrT/aOQ53jfW/YZ2tVgXIO1Khjrssqq/vf3zhpdep8xeriD+dvZhTrdYPilt1/T6tqvcEhyjQLbIPix7TzvruKbWc6V86sX48vhdxXpDfS/X9+csO2u0Pexxvt92q8vXjR7XNMO4/WS0X4PZcyfjdg9tL1OzX7C0q9n3nQFUlvL7pRzoL8uu/67yY+s9+0Bs7XLNqq91+rUvLQB4zE691Muv+pKY3WTvUNeipQj4Aed3V31NfYN+NaxV/7x6q/ckyX33wO20hVQ+uU/3Sr3cvEb/fyvxkP+d0fPyiJ6Vzsb/pCZmwcs02ueWeaclPzKDnHr1Aiov9bYiTSdmaqgIAAAAHJhYlhSkj1foAAABAKiIR6+85uELmld8gIsHsR+035tM1/adaDmvvubtrObN2e4aqWOXkSbXHKtY5KoaKLVhay5lV9EXi3+00x24ftY7ZbX26w4FBalpB4zdrTivINL3CeMS3VEw/oKXL6gK697T9vrUKfNfj33D7PTb5h4rX95+3S5LRVyP48pwvkp4fBH2ziGOWqgI+qlVe69F40FMG/PIb8QdB3+PdSzW5X+kswu/Erb9ulfte6O+rn5+kIk29uj8K/GySsfsdtQJDs0vWZKxP1enTpPKOqqkV9T6oWcWfd4Z2vbis8+1Wle97of4cNmKt8+/30iYH7Hayf0NMivVvvTvcWP/Zx4j1AQAAEFdp/DhhVhHrAwAAwBiRiPXdqvX1qvy/HDjJbvtZHFhfVPhQpapMdosCvcRsayZqQ+MVKnbtdJuqct56r1bx/rRzxfvBy6qqk49/y99eybo2/1ILl0/KX+B4jh59fHWdio1OejX92GjaZvWcM77+rt3ORFVx9yXq/1rLi9Tjzyyv+ntc2bp3jZ+pLp2oOZ1F9eOxbjoRtF5Nfcxy/n+n2zWbanX/21tK7LZbXNxv+V67rS/07nZOpdZ3feF9N/p7smm9qikEQUz/ScXTG9R75t4C5+stvse430XJ9c+7mfvUtJRDlvrc8lJF76XqPn5OUFX5etX2mA49ajmzysNlavrS4+09TO/JkvIH1ed26zHJVyo5fFHVe6LeYfV5VP+9Jc4n99I2sVikNgpwq8o3KeIfvV59DjzSzvlz4NEyNcVhVPuzUnoefTqNrv/xaurQRa28P7ZRsf6dU0Ptw7Mjf0isDwAAgG8YP0yYXcT6AAAAMEakY30v4hGazi1O87sgtF4tmM4+3bpdw7TFkV+uvYp/zR9UhWin/1YL6cejJBGR42aruOXFjSpi79TAOS79/gPD7fa3pmZucWadvnrCgcrj7LYeKeqRuV6JfuCYOl+vBNfFF7vPRNV6OntNB01f6N1PtCXiHvWmGvfrGwwc0/4PXE9UvJnO70NfsWBq5/xazkz8DNDf+yPLVLz6WPtwN+vItFRXL9Cv7wYxtQGI/vmov771tOk6v+ugxdQ+eYmJ/dDjYH0ahNt7tuUnavrJ1t5qyknpqz3tduF1/xYnO0eo6L/5+JrRv17ZHzvm/M+va/Tvwi3i3/tTdbzpDO/R/4YZaipBwU/9LfAfNj9TSEyJ9Vet3ia33hFurP/MaLNifUZOAQAAYAxuTgEAAGCMSMT6Xx36TBZvvVJEvFV61hX7r1SL5zeZ6W/xfL3CechJqh1GrI9ouHLlThERmdm1ecg9gZt0NhiJmqfWV33m3d/u+0nONNehS3rZ7UbvpL4qiy6TVfyZmMoWJnNi/a1y6+0hx/q//RGxPgAAAOCEm1MAAAAYIxLrnG7/7HgZ04s4vzq/Ub5OX4x90nWXq2/w3xW4iGqcb+qC7pmQ61G+LspxflxQUb5ela9H+UFH/LkQ5ZsqZvwEy+ziVgQAAADGiMTIKQAAQM5i5DQBN6eQk14Nd19mIJNyPcoH3BbYz2TEj7pp+PDhcu+998ppp50mK1askDvvvFM++ugjx3OvuOIKGTZsmPTs2VMaNWokn3/+uTz++OPyzjvvJH0eYn0AAADUavDgwTJu3Dh54oknpGfPnrJw4UKZM2eO5Oc779J3/vnny/vvvy8DBw6Unj17yuzZs2XWrFnSt2/fpM/FyCkAAECIYpb5uf7dd98tkydPlt///vciInL77bfLhRdeKMOHD5eHHnqoxvl33nlnwp9HjRolAwcOlMsvv9x1tDWOm9MMu2/dZ3bby17TayaoRZk7DU+tkjPZ3s7p2vSYevw2I4N/fCBdj5Z9ardHtT8rxJ7ANKPXl9jtR9pldtHxteOqovSOd6Qeo+8afrbdPmVC6hujEPGjNs2aNZOSEvXemDhxokyaNMn+c4MGDaSoqEieeeaZhJ+bN2+e9OnTR7xq2rSpfPnll0nP4+YUAAAgLJaIVIbbhd27d9e6Q1SzZs2kfv36smPHjoTjO3bskH79+nl6jttuu01at24t06ZNS3ouN6cAAABIyqo2/SAWi9U45mTQoEHy9NNPy9VXXy2bNm1Kej43p5qnN6h4496C3rWc6Z2XKF/nJ8rf/IgaSs8freL1TET5OqJ8mI4oH24yHeXrksX5mx/WPsMfd/5cTSfKd+MU8RPvoza7d++WiooKadGiRcLx5s2b1xhNrW7QoEEybdo0ueGGGzxV6otQrQ8AABCqmGWF+pXM0aNHZcmSJdK/f/+E4/3795eFC90HrK666ip59dVX5aabbpKZM2d6fj0YOdUENVqaLfpoKQAgWtxGS7MpPmJKkRSSee6552TatGmyaNEiWbBggQwbNkxatmwpL7/8soiITJkyRUREbrzxRhER+elPfyrTpk2TX/3qV/KPf/xDTj31VBEROXLkSNKiKG5OAQAAUKvXX39dTj75ZPn1r38tp512mixfvlwuuugiew5pmzZtEs4fNmyYNGjQQMaNGyfjxo2zj//973+XCy64oNbn4uYUAAAgTOYvcyoiIhMmTJAJEyY4fq/6DWeyG9DacHMakmyutedky5vd7HarQSuy/vwmmbRJLQY8tE3ynSuQ3Msb1Ws6rG3fpMeBTMr0dXdPqfoMfbawWy1nZsaGGT3sdsFPl6X0GKyDCpNwcwoAABCmCOwQlU1U6wMAAMAYjJyGxC3Kf2r9v+z2/e2+H+hzHv/hqXa71fmZi/I7lDSy2+uKD2XseYJClO9usjbl4SYfr5NbdJrpKH/a5gUiInJ9/jkZfR5Ei37dZWIaj1uUH5++lempW6lG+W6I+BE2bk4BAADCYonESPUTEOsDAADAGIycGqZxXkWNY3O3LrXbA1qeabdvWVNmt+vFKu32hI6Fjo998PzatxgTCabqVI/y3fqeK97eolZduLRV9lddyDQ/Ub4J4nH+rHK1DfAVrXuF1R3bnzerxdavzu9Ty5lqaoJIetMT3F4DL69N/LrOxWu6cSyW9JygqvubxGr/PH97f2O7Pb5jJ7s9fG2p3Xb7PHczYu0ax8dMlUkR/3TtvXGtz/dGOj+bFRREJWDkFAAAAMbg5hQAAADGiEkE9iVYXVIqI3o9EHY3AACAhB/xB2H8oielc7G/aROZsHrlVhnx8z+E2ocxYwdIcbE503gYOQUAAIAxuDkFAACAMSJdrZ8rldLPbfjY8fjdBWfX+nPxBZ5FvC3ynMkF/v0yqZrapL4gPfHfZVi/x1xfnSKq3FZLSHWTidqMLFtitxt9U62fic9bv5//QTOpij/6LKr1q2HkFAAAAMaI9MgpAABApFkSgdL07KJaHwAABCJKEb8x1fqfb5ERQ0Ku1n/hQqr1AQAAACfE+gAAACGKURCVICdvTnOlij9VD5epiuHH21MxHPd6uVoVYXDr2ldCAIIU1F7tqHseXLfMbo/p0CPEnnhDFT+CQKwPAAAAY+TkyCkAAEBkEOsnyMmb01yO8r1E9l6i/Kc3qIjl3oLetZyZO4jyERY9yo8v1M8i/dDdU7rCbj9b2M1uH7HqOZ7/aNmndntU+7My17E0EPEjVTl5cwoAABAZlWF3wCzMOQUAAIAxGDmNmKCq7+tKlA+YhjgfTvQo38txU6N8N0T88IObUwAAgLBYrHNaHbE+AAAAjMHIKQBk2HMb1AYQdxewakQuu710ld1+obBLiD0xFxG/A0ZOEzByCgAAAGNwcwoAAABjEOsDQIYR5dcdRPn+EPGLiFjE+tUwcgoAAABjcHMKAAAAY0Q61p9Zrob9r2ydG4vKP1y21G7HF9wfsXaNfWx8x06OP+flHPjz580L7fbV+X1C7Enmzd6i9um+qFW0FveOqqfW/8tu39/u+0nPN+l3NHnTR3b7pjZ9Q+yJf9ns+12lK0VE5PnCrvaxIWvW2+1XOrVz/Llb1pQ5Hp/YqX2AvTNPnY742b40ASOnAAAAMEakR04BAAAijR2iaoj0zWmUo/ynN6iYQt/nPh7li4jcU7pCRNz3VtYR5afOLb7P9ShfF3ZMXBfpUf7o9SV2+5F2xY7n678jp+k/2RS1KD+b7lv3md3+XYfTRSQxpvcSzed6fO+FU8RfJ+J9iAixPgAAAAwS6ZHTXORnREQvgtK5jaLGR2JFvI3GBuHdLUvs9sWtirLynFFmUtFLVMwqX2S3r2jdS0RE3t6iRiIvbeU8EplNL25cYLd/2facGt/XR0u9fAbox/Vr5pPD6pxR7TN3/UStIGr6ZvX6H/WQno7doNKUOwuSJygPrltmt8d06GG3nQqi3Pgtgoo/ttfHD4L+Ol6bX/M6zpT4iGlOF0kR6ydg5BQAAADGYOQUAAAgTIycJoiJiPGvyOqSUhnR64GMP08urpt6e+kqu61vqxd2QQWgc4rm4R4XI7q8rHPqRp/K1TB2zG5nK9Y3SRAR//hFT0rn4sKgupSy1cvL5fZrJoTah9/+4XIpLg5/ClQcsT4AAACMQawPAAAQJmL9BJG+OQ06ho9ylO9l+1K9Wr8uia9jWpfWLY0aonxnepSvV+UvOKxCL7dpOV7WTq0rwqoyd+IlyveyLmr/4w/a7efT71bk1OmtTusAYn0AAAAYI9IjpwAAAJFmiUhl2J0wS6RvTqMcw+ueWK8qlfdbDe22nyp6PcrXI/6BjQ/Z7QEt1ePp1fq5Llmc77Z9adREYcODKPTRVG6bMrhV9OtR/tyt6v2ufw4gGEGvqqBH+XrEf2mTA3Z7QEt1PdT1VR2I+HNPpG9OAQAAos2SGAVRCZhzCgAAAGPUqUX449X9UZsO4KUSHwC8oIrfHF6q8pG6ZBG/MYvwf7ZZ7hj8Uqh9GD11kFGL8BPrAwAAhIlYPwGxPgAAAIxRp0ZOoxbnxxfNP2Q1SHquHv3rwp4GkM3qbJMW2gbC8GiZWqi/gbb3uh7f6219pZCH2qmNEMZuqFrB4s6C6K5eYRI9vj8mMbvtFuXr5+vCjv6j9hlLFX901ambUwAAAONUEuvriPUBAABgDEZODfZsYbdav29qlK9zi/Lf3qIqhi9tFUyFYBRiJiCTRrV3Xqgf4fIS37udE3aUr4vyZ6xTxH8ov0lY3UlkCQVR1TByCgAAAGNwcwoAAABjRGIR/p07d8r+/ftl9+7dYXcFOaBZs2ZcS0gb1xGCwHUUnrZt20rz5s3D7oasXrZZ7hj0Qqh9GP3aYBbh96t58+ZSUlJi1AuH6OJaQhC4jhAEriOgpkjcnAIAAOQmi4KoaphzCgAAAGNE5uZ04sSJYXcBOYJrCUHgOkIQuI6AmiJREAUAAJCLVi/bJHdcNi7UPox+/Wqj5j5HZuQUAAAAuY+bUwAAABiDan0AAICwWCJiVYbdC6MwcgoAAABjMHIKAAAQJtY5TcDIKQAAAIzBzSkAAACMQawPAAAQGkukklhfx8gpAAAAjMHIKQAAQJgoiErAyCkAAACMwc0pAAAAjEGsDwAAEBZLiPWrYeQUAAAAxuDmFAAAAMYg1gcAAAgTsX4CRk4BAABgDEZOAQAAQmOJVFaG3QmjMHIKAAAAY3BzCgAAAGMQ6wMAAISJgqgEjJwCAADAGNycAgAAwBjE+gAAAGFh+9IaGDkFAACAMRg5BQAACFMlI6c6Rk4BAABgDG5OAQAAYAxifQAAgNBYYllsX6pj5BQAAADGYOQUAAAgLJZQEFUNI6cAAAAwBjenAAAAMAaxPgAAQJjYISoBI6cAAAAwBjenAAAAMAaxPgAAQJgqWedUx8gpAAAAjMHIKQAAQFgsi4Koahg5BQAAgDG4OQUAAIAxiPUBAABCZFEQlYCRUwAAABiDkVMAAIAwURCVgJFTAAAAGIObUwAAABiDWB8AACAsliVSSayvY+QUAAAAxuDmFAAAAMYg1gcAAAiTxTqnOkZOAQAAYAxGTgEAAEJkURCVgJFTAAAAGIObUwAAABiDWB8AACA0FgVR1TByCgAAAGNwcwoAAABjEOsDAACExaJavzpGTgEAAJDU8OHDpaysTA4ePCiLFy+Wvn371nr+eeedJ4sXL5aDBw/KunXr5NZbb/X0PNycAgAAhMmqDPfLg8GDB8u4cePkiSeekJ49e8rChQtlzpw5kp+f73h+QUGBzJ49WxYuXCg9e/aUMWPGyIsvviiDBg1K+lwxEWEsGQAAIASrS0plRK8HQu3DmEX3S3Fxca3nfPLJJ7Js2TK55ZZb7GNr1qyRN954Qx566KEa5z/55JMyaNAg6dSpk31s0qRJ0q1bN+nTp0+tz8WcUwAAgJCU7V4rYxbdH2ofGjVqJCUlJfafJ06cKJMmTbL/3KBBAykqKpJnnnkm4efmzZvneqN59tlny7x58xKOzZ07V2688UapX7++VFRUuPaHm1MAAICQ/PjHPw67C0k1a9ZM6tevLzt27Eg4vmPHDunXr5/jz7Ro0ULmz59f4/wGDRpIs2bNZPv27a7Px5xTAAAAJGVZiTNBY7FYjWPJznc6Xh03pwAAAHC1e/duqSsG3RwAAAE0SURBVKiokBYtWiQcb968eY3R1Ljt27c7nn/06FHZs2dPrc/HzSkAAABcHT16VJYsWSL9+/dPON6/f39ZuHCh4898/PHHNSL//v37y+LFi2udbxpn8cUXX3zxxRdffPHFl9vX4MGDrcOHD1tDhgyxunTpYo0dO9bau3ev1aZNG0tErClTplhTpkyxzy8oKLD27dtnPf/881aXLl2sIUOGWIcPH7YGDRrk5fnC/wvzxRdffPHFF1988WX21/Dhw63169dbhw4dshYvXmyde+659vc++OAD64MPPkg4/7zzzrOWLFliHTp0yCorK7NuvfVWT8/DOqcAAAAwBnNOAQAAYAxuTgEAAGAMbk4BAABgDG5OAQAAYAxuTgEAAGAMbk4BAABgDG5OAQAAYAxuTgEAAGCM/w8di77DQvN8gAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -266,7 +276,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Joint survival function: 100%|██████████| 47838/47838 [00:06<00:00, 7400.11it/s]\n" + "Joint survival function: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47838/47838 [00:05<00:00, 9417.00it/s]\n" ] } ], @@ -288,7 +298,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -327,7 +337,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -365,13 +375,12 @@ "ExecuteTime": { "end_time": "2020-03-25T14:11:03.303188Z", "start_time": "2020-03-25T14:11:02.940034Z" - }, - "scrolled": false + } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -454,13 +463,12 @@ "ExecuteTime": { "end_time": "2020-03-25T14:11:05.868308Z", "start_time": "2020-03-25T14:11:04.686689Z" - }, - "scrolled": false + } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -496,7 +504,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -520,9 +528,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "elephant_nixio", "language": "python", - "name": "python3" + "name": "elephant_nixio" }, "language_info": { "codemirror_mode": { @@ -534,7 +542,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.7" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -597,5 +605,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 48855eda4..16f503757 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -73,8 +73,8 @@ }, "outputs": [], "source": [ - "# Download data\n", - "!curl https://web.gin.g-node.org/INM-6/elephant-data/raw/master/dataset-1/dataset-1.h5 --output dataset-1.h5 --location" + "# Download trial data\n", + "!curl https://gin.g-node.org/INM-6/elephant-data/raw/master/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" ] }, { @@ -464,10 +464,13 @@ }, "outputs": [], "source": [ - "block = neo.io.NeoHdf5IO(\"./dataset-1.h5\")\n", - "sts1 = block.read_block().segments[0].spiketrains\n", - "sts2 = block.read_block().segments[1].spiketrains\n", - "spiketrains = np.vstack((sts1,sts2)).T" + "io = neo.io.NixIO(\"./dataset-1.nix\",'ro')\n", + "block = io.read_block()\n", + "\n", + "spiketrains = []\n", + "# each segment contains a single trial\n", + "for ind in range(len(block.segments)):\n", + " spiketrains.append (block.segments[ind].spiketrains)" ] }, { @@ -498,9 +501,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "elephant_nixio", "language": "python", - "name": "python3" + "name": "elephant_nixio" }, "language_info": { "codemirror_mode": { @@ -512,7 +515,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.7" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -574,5 +577,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/requirements/environment-docs.yml b/requirements/environment-docs.yml index 2068f16e5..ec388c344 100644 --- a/requirements/environment-docs.yml +++ b/requirements/environment-docs.yml @@ -13,7 +13,7 @@ dependencies: - pandas - scikit-learn - statsmodels - - jinja2 + - jinja2==3.0.3 # prevent bug happening in 3.1.0 for docs - pip: - neo>=0.10.0 - viziphant diff --git a/requirements/requirements-tutorials.txt b/requirements/requirements-tutorials.txt index 6fb237785..3ee70c3cd 100644 --- a/requirements/requirements-tutorials.txt +++ b/requirements/requirements-tutorials.txt @@ -1,4 +1,4 @@ # Packages required to execute jupyter notebook tutorials matplotlib>=3.3.2 h5py>=3.1.0 -nixio==1.5.0b3 +nixio>=1.5.0 \ No newline at end of file From dc893bea33583b06e7269b58c12892b6ce98c134 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 30 Mar 2022 18:06:41 +0200 Subject: [PATCH 48/63] Enh/elephant data versioning (#463) * added function and environment variable to specifiy elephant-data download URLs * fixed errors * changed ASSET tutorial to work with nixio==1.5.0b3 * added docstrings * use return of download_elephant_data in tutorials * rename variable, update docstrings * fixed return of download_elephant_data * added version specific URL (depending on elephant version) * added in 'v' for versioning , e.g. v0.10.0 * changed check to see if version is available * Enh/data utils (#92) * added handling for SSL verification error * update ASSET and UE tutorials * Enh/data utils (#93) * allow download without verified certificate * rename data_utils to datasets, and download_elephant_data to download_datasets * fixed UE tutorial * fixed pep8 * removed download.py --- doc/tutorials/asset.ipynb | 27 +-- doc/tutorials/gpfa.ipynb | 94 ++-------- doc/tutorials/granger_causality.ipynb | 6 +- doc/tutorials/parallel.ipynb | 9 +- doc/tutorials/statistics.ipynb | 4 +- doc/tutorials/unitary_event_analysis.ipynb | 16 +- elephant/datasets.py | 179 +++++++++++++++++++ elephant/test/download.py | 67 ------- elephant/test/test_spectral.py | 7 +- elephant/test/test_spike_train_synchrony.py | 17 +- elephant/test/test_unitary_event_analysis.py | 2 +- 11 files changed, 247 insertions(+), 181 deletions(-) create mode 100644 elephant/datasets.py delete mode 100644 elephant/test/download.py diff --git a/doc/tutorials/asset.ipynb b/doc/tutorials/asset.ipynb index ec61445bf..2a06ee600 100644 --- a/doc/tutorials/asset.ipynb +++ b/doc/tutorials/asset.ipynb @@ -41,7 +41,8 @@ "import quantities as pq\n", "import neo\n", "import elephant\n", - "from elephant import asset" + "from elephant import asset\n", + "from elephant.datasets import download_datasets" ] }, { @@ -85,17 +86,21 @@ "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " % Total % Received % Xferd Average Speed Time Time Time Current\n", - " Dload Upload Total Spent Left Speed\n", - "100 42.1M 0 42.1M 0 0 3064k 0 --:--:-- 0:00:14 --:--:-- 5532k\n" + "elephant/elephant/datasets.py:153: UserWarning: No corresponding version of elephant-data found.\n", + "Elephant version: 0.10.1. Data URL:https://gin.g-node.org/INM-6/elephant-data/raw/v0.10.1/README.md, error: HTTP Error 404: Not Found.\n", + "Using elephant-data latest instead (This is expected for elephant development versions).\n", + " warnings.warn(f\"No corresponding version of elephant-data found.\\n\"\n", + "Downloading http://datasets.python-elephant.org/raw/master/tutorials/tutorial_asset/data/asset_showcase_500.nix to '/tmp/elephant/asset_showcase_500.nix': 42.1MB [00:28, 1.54MB/s]\n" ] } ], "source": [ - "!curl https://gin.g-node.org/INM-6/elephant-data/raw/master/tutorials/tutorial_asset/data/asset_showcase_500.nix --output asset_showcase_500.nix --location" + "# Download data\n", + "repo_path='tutorials/tutorial_asset/data/asset_showcase_500.nix'\n", + "filepath=download_datasets(repo_path)" ] }, { @@ -116,7 +121,7 @@ }, "outputs": [], "source": [ - "with neo.NixIO('asset_showcase_500.nix', 'ro') as f:\n", + "with neo.NixIO(f\"{filepath}\", 'ro') as f:\n", " block = f.read_block()\n", "segment = block.segments[0]\n", "spiketrains = segment.spiketrains" @@ -276,7 +281,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Joint survival function: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47838/47838 [00:05<00:00, 9417.00it/s]\n" + "Joint survival function: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47838/47838 [00:05<00:00, 9257.33it/s]\n" ] } ], @@ -528,9 +533,9 @@ ], "metadata": { "kernelspec": { - "display_name": "elephant_nixio", + "display_name": "inm-elephant", "language": "python", - "name": "elephant_nixio" + "name": "inm-elephant" }, "language_info": { "codemirror_mode": { @@ -542,7 +547,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.10" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorials/gpfa.ipynb b/doc/tutorials/gpfa.ipynb index 2854c5b21..268b64df2 100644 --- a/doc/tutorials/gpfa.ipynb +++ b/doc/tutorials/gpfa.ipynb @@ -289,7 +289,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -430,7 +430,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA40AAAFgCAYAAAAfEZxMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd3hcV52/3zO9z6hXW3LvLXZ6IQ0SCCQsvW6ApcPuwi5l4Qe7YYGl7tKWpW6ooW4IvSQhPbGT2Ekc9yrJ6tKMNL3dcn5/3KuxZBXLjm3ZyXmf5z7S7efekeacz/k2IaVEoVAoFAqFQqFQKBSKqXDMdQMUCoVCoVAoFAqFQnH2okSjQqFQKBQKhUKhUCimRYlGhUKhUCgUCoVCoVBMixKNCoVCoVAoFAqFQqGYFiUaFQqFQqFQKBQKhUIxLUo0KhQKhUKhUCgUCoViWpRoVDxjhBAfFUJ891QfO4trSSHE4mn23SeEeOupuM/pRghxpRCiZ67bcSxCiF1CiCvnuh0KhUKhOLcQQrTbfbRrrtsyHiHEn4QQN891O852jjcumWn8pXj2okSjYgJCiDcJIXYIIfJCiAEhxDeEELGZzpFS/oeUclYC7USOPVMIITqFENeeomudlR3lySClXCWlvG+u26FQKBTPVU62fzrVE6fPFpEgpXyhlPIHc90Oe6z10Gm8/veFEJ86Xdc/lQghmoQQ3xFC9AkhskKIw3b7l9v7x8ZVWXvpFEL8y7jzpRAiN25/cty+K+39H56DR3vWoUSjooIQ4p+BzwEfBKLARUAbcJcQwjPNOee8OFIoFAqFQqE4mxBCOOe6DacbIUQN8AgQAC4HwsB5wP3A8485PCalDAGvBf5VCHH9uH3rpJQhe4mN234zMAL87Wl6hOcUSjQqABBCRIBPAH8vpfyzlFKTUnYCrwLagTfYx90ihPg/IcSPhRBp4E32th+Pu9bfCiG6hBAJIcTHx8+Ujj923OzRzUKII0KIuBDi/427zgVCiM1CiKQQol8I8d/TidfjPNsiIcQ9dnviQojbxqynQogfAfOB39kzVB+yt18khHjEvvf28W6a9gzuJ4UQDwshMkKIO4UQtfbuB+yfSft6F0/RHr89izYqhNgNnD9u3weFELcfc/xXhRBfmcW9EUL80rYQp4QQDwghVo3b930hxP/Y7jlZ+xqNQogv223ZK4TYMO748Z+bU1iuxYfs+24TQswTFl8SQgwJIdLCslKvPtHPSKFQKBSzRwhRJYT4vRBi2P7+/r0QotXe92msAfh/29/1/21vXy6EuEsIMSKE2CeEeNW4631fCPF1IcQf7O/4R4UQi+x9Y/3advt6r56iPU4hxBftPvYwcMO4fa8UQmw75vh/EkL85nj3tvd/RQjRbfcx24QQl4/bd4vd7/3YPneHEGKpEOIjdr/ULYR4wbjjJ1hghRBvE0Lssc/dLYQ4z97+YSFEr719nxDimmk+B6/93EeEEINCiG8KIfz2vj8KIf5z3LE/E0LcKoRYAXwTuFiMs4zZ7+Eb9nk54CohxA1CiCftZ+8WQtxyzP0vE0fHKt3CsmC+HXg98CH7+r+zj20WQtxu/810CCH+Ydx1ph2XzMCLhGUVjAshviCEcAghPPbf15px164Xlvda3RTXeD+QBt4opTwkLZJSyu9JKb821U2llJuBXcCMYw0hRBB4BfAeYIkQYtMsnkkxE1JKtagF4HpAB1xT7PsB8FP791sADXgp1qSD3972Y3v/SiALXAZ4gC/ax1877vyxY9sBCXzHvs46oASssPdvxLJ2uuxj9wDvG9cuCSye5nnuA95q/74Ya8bKC9RhCbsvjzu2c6x99noLkABeZD/j8+31unHXPgQstdt9H/DZY55p0nscd/3PAg8C1cA8YCfQY+9rAnJYM2rYzz4EbDzeve39b8GaqfMCXwaeGrfv+0Dcfq8+4B6gA2sGzgl8Crh3qveCZX3eASwDhP1Z1QDXAduAmL19BdA013/PalGLWtTybFiO7Z/Gba8BXo5loQkDvwR+PW5/pQ+014NAN/Bmu1/ZYPcHK+3937f7uQvs/bcBPxt3/rT9rb3/ncBeu0+rBu4d6wvt/mgEu2+3j38SePks7/0G+3ldwD8DA4DP3ncLULT7IhfwQ7tf+3+AG3gb0DHVewFeCfRiCSSBNVZos/u5bqDZPq4dWDTNc38J+K39zGHgd8Bn7H2NWP331Vgi7jAQtve9CXjomGt9H0gBl2KNPXzAlcAae30tMAi81D6+DchgWd7c9jtaP+5anxp3bQdWX/2vWGOzhXZ7rrP3Tzsumea5pf0ZV2NNvO8f917/B/jcuGP/EfjdNNfZAtxynP+Bdo7+LQn7/eSBa2b62wTeCPRjjW9+B3xtrv+fz/VFWRoVY9QCcSmlPsW+fnv/GJullL+WUppSysIxx74C68vhISllGesLSh7n3p+QUhaklNuB7ViCBCnlNinlFimlLi2r57eA553og0kpD0op75JSlqSUw8B/Hec6bwD+KKX8o/2MdwFbsUTkGN+TUu63n/8XwPoTaNKrgE9LKUeklN3AV8e1tR9L1L7S3nQ91ucyfpZ22ntLKW+VUmaklCWsznSdECI67tw77PdaBO4AilLKH0opDeDnWAOJqXgr8DEp5T5psV1KmcCaEAgDywEhpdxjP4NCoVAoThNSyoSU8nYpZV5KmQE+zcz92ouBTmlZcHQp5ZPA7Rzta8DqHx6zxwG3ceL92pellN1SyhHgM+PaWsLqX8Y8llZhCYHfz+beUsof28+rSyn/E0uELht37oNSyr/Y5/4Sa3L4s1JKDfgZ0C6mzs3wVuDzUsrH7X7toJSyCzDse6wUQrillJ1SykPHniyEEMDbgffb/XkG+A/gNXa7B4B3YU28fwX4W/uYmfiNlPJhe+xRlFLeJ6XcYa8/DfyUo5/z64C7pZQ/lZZ3WEJK+dQ01z0fa+L736WUZSnlYawJ+9fY+6cdl8zA5+zjj2BNUr/W3v4D4LX2+wFLvP1ommvUYk0CACCEuNG2mmaEEHcec2wca/Lhu8C/SCn/Om7fE/Z5SSHEWNtvBn5uj29+ArxGCOGexXMppkGJRsUYcaBWTB2j2GTvH6N7hus0j98vpcxjzSDOxMC43/NACMB2Mfm9sNwt01hfxrVTXWAmhBANtltIr32dHx/nOm3AK8d9ASWxLKdNx2vzLJnwjoCuY/b/ALtztX8e+2U73ftyCiE+KywX0jTWDDVMfNbBcb8Xplif7jnmYVk4JyClvAf4b+DrwJAQ4tvCcnVWKBQKxWlCCBEQQnxLWKEgaazJxpiYPg6uDbjwmH7t9VjWsDFOd7/2OltIvBH4hS0mj3tvIcQHbBfSlN3uKDP3a3FbKIytM82zTNevHQTehzXxOmSPH5qnOL8Oy9K7bdw7/bO9fYzfYVm69kkpZ5P4ZsL4SghxoRDiXtulNIVl0R179inbPw1tQPMxn/9HgQZ7//E+v+O1tcu+BlLKR7E+wyuFlcxmMZY1dioSjBtbSSl/K62YxPdjWUTHUyulrJJSrpBSHitqz5NSxuzlH4QQ84CrsCYgAH6DZbm9AcVJo0SjYozNWK6hLxu/UQgRAl4IjJ/Rmcly2A+0jjvfj+UycTJ8A8vdZYmUMoL1BSdmPmVK/gOrzWvs67zhmOsc+zzdwI/GfQHFpJRBKeVnZ3Gv41lVwXpH88atzz9m/6+BtcKKDXwxR7/0jsfrgJuAa7E61XZ7+8m8s2PpBhZNtUNK+VUp5UYs1+SlWK6sCoVCoTh9/DOWte1Cu1+7wt4+9n0/Vb92/zH9WkhK+a5T1J4Z+zUp5RagjBVr+TqmtzxNQFjxix/CsoRV2YIixenv134ipbwMS2xJrCSBxxLHEqWrxr3TqLSStYzxaazQmiYhxGvHbZ9urHDs9p9gCa55UsooVizk2LNP2/4prtON5aY7/vMPSynHPKiONy6ZimOP7xu3Pjb5/Ubg/2zvpqn4K/BSIcSp1iNvxNI4vxNCDGC54vqwrI+Kk0SJRgUAUsoUViKcrwkhrhdCuIUQ7Vjujz3M8gse+D/gJUKIS4SVtOYWTv7LPYwVIJ21Z6tOtnMLY8VZpoQQLUwWNYNY/v1j/BjrGa6zrXc+YaVtbuX4DAPmMdc7ll8AHxFWIoNW4O/H77S/XP8Pq7N4zHb9mA1hLOGfwJr9/I9Znjcbvgt8UgixRFisFULUCCHOt2dC3VixmEWs51coFArFqcFt90Njiwvr+76AlXStGvi3Y845tl/7PbBUCPFGu39329/fK2bZhmOvdyy/AP5BCNEqhKgC/mWKY36I5ZmizdLqBtZz6lh9q0sI8a/AqfJm+S7wASHERrtfWyyEaBNCLBNCXC2E8GL1aQWm6NeklCaWi+eXhBD1AEKIFiHEdfbvV2DFkP4tllj5mj0GAet9torjJ/cLAyNSyqIQ4gIswT3GbcC1QohXCSFcdp+8ftz1x39ejwEZYSX48dtjm9VCiLGENzOOS6bhg/bx87DiFn8+bt+Pgb/BEo4/nOEa/wVUAT8SVtJCIYQIc2Ku0VNxM9aYdv245eVYyXtO1pDxnEeJRkUFKeXnsax5X8QSa49izU5dc4wbyUzX2IX1ZfMzrJmrLFYg+KzOP4YPYH1BZrC+mH8+8+HT8gmsFM4p4A/Ar47Z/xngY7bLxgdsf/6bsN7FMNY7+CCz+H+x3XE/DTxsX++iadrThRWsfydTC/IfYAW/z1asg/XF3IUV2L8bK8D8VPFfWJ3KnVh/G/+LlYgngvXZjNr3TgBfOIX3VSgUiuc6f8QSLmPLLVgxZH4sa9cWLLfI8XwFeIWwsmF+1Y6lewFWDFsfljvo57Bi92bDLcAP7H7tVVPs/w7wF6y8BE8wuZ8Fqz9bjSUoZstfsJ5tP1YfU2TmEJlZI6X8JVZ//ROsccavsRK7eLESw8Sx3lM98JFpLvNh4CCwxXYTvhtYZodp/BB4r5SyV0r5IFa/+T3bRfcerAygA0KI+DTXBng38O9CiAxWjohfjGv/EaxcC/+MFev3FHZOCPteK+3P69e2u+6LscRTh/1s38XySoLZjUuO5TdYyXWewhpb/e+4tnVj/R1IrAQ7UyKljGMlPCwCD2F9Dk9hieWTMhTY46424OtSyoFxy2+xPqvXznwFxXQIKWfjTadQnBy2e2sSy8W0Y46bc84ghJiP5ZrbKKVMz3V7FAqFQqF4JtjhKkNY8WcH5ro9itOLEOJWoE9K+bG5bovi1KAKsytOOUKIl2D5qQssq+UOjiZlURwH27f/n7BSjivBqFAoFIpnA+8CHleC8dmPHd70MqbPyK44B1GiUXE6uAnLtUFglap4jVQm7VkhrGK0g1huItfPcXMUCoVCoXjGCCE6scYEL53blihON0KIT2JlP/2M8jB7dqHcUxUKhUKhUCgUCoVCMS0qEY5CoVAoFAqFQqFQKKblOeWeWltbK9vb2+e6GQqF4jnOtm3b4lLKuuMfqVA8e1F9skKhUJxdzDQ+eU6Jxvb2drZu3TrXzVAoFM9xhBBdc90GhWKuUX2yQqFQnF3MND5R7qkKhUKhUCgUCoVCoZgWJRoVCoVCoVAoFAqFQjEtSjQqFAqFQqFQKBQKhWJanlMxjQqFQqFQKBQKxdmCpmn09PRQLBbnuimK5xA+n4/W1lbcbvesz1GiUaFQKBQKhUKhmAN6enoIh8O0t7cjhJjr5iieA0gpSSQS9PT0sGDBglmfp9xTFQqFQqFQKBSKOaBYLFJTU6MEo+KMIYSgpqbmhK3bSjQqFAqFQqFQKBRzhBKMijPNyfzNKdGoUCgUCoVCoVAoFIppmVPRKIS4VQgxJITYOc1+IYT4qhDioBDiaSHEeeP23SyEOGAvN5+5VisUCoVCoVAoFOc+iUSC9evXs379ehobG2lpaamsl8tlAH7729/y2c9+dsbrfP/73+e9733vmWjyaScUCk3alkwm+Z//+Z+Tut6LXvQiksnkCZ9333338cgjj5zUPU8Hc50I5/vAfwM/nGb/C4El9nIh8A3gQiFENfBvwCZAAtuEEL+VUo6e9hYrFAqFQqFQKBTPAmpqanjqqacAuOWWWwiFQnzgAx+o7Nd1nRtvvJEbb7xxjlo4GV3XcbnOrIQZE43vfve7T7g9f/zjH0/qnvfddx+hUIhLLrlk1uecznczp5ZGKeUDwMgMh9wE/FBabAFiQogm4DrgLinliC0U7wKuP/0tVjyX0A2TZL5Mf6pARzzH0z1JthxOsLsvTVciRzxboqgZSCnnuqkKhUKhUCgUp4Q3velNvPOd7+TCCy/kQx/60AQr4u9+9zsuvPBCNmzYwLXXXsvg4OCM13rssce4+OKL2bBhA5dccgn79u0D4KKLLmLXrl2V46688kq2bt1KLpfjLW95CxdccAEbNmzgN7/5DWBZMm+88UauvvpqrrnmGrLZLNdccw3nnXcea9asqRwH8MlPfpJly5Zx2WWX8drXvpYvfvGLABw6dIjrr7+ejRs3cvnll7N3714AOjo6uPjii1mzZg0f+9jHpnyOf/mXf+HQoUOsX7+eD37wg9x3331cfvnl3HjjjaxcuRKAl770pWzcuJFVq1bx7W9/u3Jue3s78XgcgB//+MdccMEFrF+/nne84x0YhgHAn//8Z8477zzWrVvHNddcQ2dnJ9/85jf50pe+xPr163nwwQfp7Ozk6quvZu3atVxzzTUcOXJkys9ryZIlDA8PA2CaJosXL66sPxPm2tJ4PFqA7nHrPfa26bYrFNNSKBs8cWSUp7qT7OxN8XRPit5k4bTftybo4by2Kjbay5qWKD6387TfV6FQKBRnBt0wyZUNciWdXEknW9IpaiYSScDjoirgpiroIex1qaQnium5JXqarps64VN6enp45JFHcDqdfP/7369sv+yyy9iyZQtCCL773e/y+c9/nv/8z/+c9jrLly/nwQcfxOVycffdd/PRj36U22+/nVe/+tX84he/4BOf+AT9/f309/ezadMmPvrRj3L11Vdz6623kkwmueCCC7j22msBeOKJJ3j66aeprq5G13XuuOMOIpEI8Xiciy66iBtvvJGtW7dy++23s337djRN47zzzmPjxo0AvP3tb+eb3/wmS5Ys4dFHH+Xd734399xzD//4j//Iu971Lv72b/+Wr3/961M+x2c/+1l27txZscred999PPHEE+zcubNStuLWW2+lurqaQqHA+eefz8tf/nJqamoq19izZw8///nPefjhh3G73bz73e/mtttu44UvfCFve9vbeOCBB1iwYAEjIyNUV1fzzne+c4Ll9yUveQk333wzN998M7feeiv/8A//wK9//etJn1c0GuW2227jfe97H3fffTfr1q2jrq7uhP8GjuVsF43PGCHE24G3A8yfP3+OW6M4E+wfzHDHk73ctXuQg0PZZ3StsM+F3+3E53aSLemkCxqL60Pkyjq5kkG2pFPWzRmvkciVuWv3IHftnno2bllDmOtWNfCCVY2sao6oAYVCoVCcAxTKBo91juBxOhCAbpo4HYKo301DxEfE58LtdKCbJqN5ja54nkxJq5zvFIJYwENVwE0s4MHjUrkJFWcPr3zlK3E6J09w9/T08OpXv5r+/n7K5fJx6/ylUiluvvlmDhw4gBACTbP+B171qlfxghe8gE984hP84he/4BWveAUAd955J7/97W8r1sFisVixqD3/+c+nuroasGoNfvSjH+WBBx7A4XDQ29vL4OAgDz/8MDfddBM+nw+fz8dLXvISALLZLI888givfOUrK20rlUoAPPzww9x+++0AvPGNb+TDH/7wrN7RBRdcMOH5v/rVr3LHHXcA0N3dzYEDByaIxr/+9a9s27aN888/H4BCoUB9fT1btmzhiiuuqFxr7BmPZfPmzfzqV7+qtPNDH/pQZd/4z+stb3kLN910E+973/u49dZbefOb3zyr5zkeZ7to7AXmjVtvtbf1Alces/2+qS4gpfw28G2ATZs2KT/CZxFSSrZ1jfKjLV385qm+WZ1zfnsVG+ZXsbolypqWKG3VARyO0yfSpJQMpIs80ZVkW9co27pG2N4zccZv32CGfYMZvnrPwQnbX7ahhddf1MZ582NKSCoUCsVZRG+ywP37hmitCiClRAqoC/sIeJyUdJNUQWM4U6JsmGjG1BOLZcOkI55lZ8nAlBKvy0HE72ZRXZCW2OntmxRnKSdhETxdBIPBKbf//d//Pf/0T//EjTfeyH333cctt9wy43U+/vGPc9VVV3HHHXfQ2dnJlVdeCUBLSws1NTU8/fTT/PznP+eb3/wmYI2bbr/9dpYtWzbhOo8++uiENt12220MDw+zbds23G437e3tM9YdNE2TWCxWsRQey8mMs8a357777uPuu+9m8+bNBAIBrrzyykntkVJy880385nPfGbC9t/97ncnfO+Z2jJv3jwaGhq45557eOyxx7jtttue8fXh7BeNvwXeK4T4GVYinJSUsl8I8RfgP4QQVfZxLwA+MleNVJwZdMPkDzv6+Z97D7FvMDPtcc1RHy87r5XrVzeysikypx2vEIKmqJ8b1vq5YW3TpP2mKdnek+Qvuwb5y64BOuK5yr5fPdnLr57srazPrw7w/ucv4cZ1LTjVYEKhUCjOGPFsia5EnpJmMJorM5wr84KVDTREfM/4+1g3TNJFnVRBI5Et8XjnKH/ODiCBqoCHhXVBakNeon43YZ9bff8r5pRUKkVLixUR9oMf/OCEjh/v5grw6le/ms9//vOkUinWrl0LwHXXXcfXvvY1vva1ryGE4Mknn2TDhg1TXre+vh632829995LV1cXAJdeeinveMc7+MhHPoKu6/z+97/n7W9/O5FIhAULFvDLX/6SV77ylUgpefrpp1m3bh2XXnopP/vZz3jDG94wrcAKh8NkMtOPPVOpFFVVVQQCAfbu3cuWLVsmHXPNNddw00038f73v5/6+npGRkbIZDJcdNFFvPvd76ajo2OCe2o4HCadTlfOv+SSS/jZz37GG9/4Rm677TYuv/zyadvz1re+lTe84Q288Y1vnNJifDLMqWgUQvwUy2JYK4TowcqI6gaQUn4T+CPwIuAgkAfebO8bEUJ8EnjcvtS/SylnSqijOEfZ1jXCv/9u9yTr3BgL64K86ZJ2blrXQjTgPsOte+Y4HIIN8y3r57+8cHlleyqv8asne/jxli4ODVtC8shInvf/fDvv//l2ABbWBvm3G1fxvKXP3E9doVAoFJMxTcmT3UlcDsGq5ggDqSIup4MXrW06ZR4gLqeD6qCH6qCHBbVBNrUfdb8bSBXZN5iheyQPQhDzu4+6sUoI+Vw0Rf3UBD3KMqk4I9xyyy288pWvpKqqiquvvpqOjo4Zj//Qhz7EzTffzKc+9SluuOGGCfte8YpX8I//+I98/OMfr2z7+Mc/zvve9z7Wrl2LaZosWLCA3//+95Ou+/rXv56XvOQlrFmzhk2bNrF8uTWGOv/887nxxhtZu3YtDQ0NrFmzhmjUihW97bbbeNe73sWnPvUpNE3jNa95DevWreMrX/kKr3vd6/jc5z7HTTfdNOVz1NTUcOmll7J69Wpe+MIXTnqW66+/nm9+85usWLGCZcuWcdFFF03YL4Rg5cqVfOpTn+IFL3gBpmnidrv5+te/zkUXXcS3v/1tXvayl2GaJvX19dx111285CUv4RWveAW/+c1vKkL6zW9+M1/4wheoq6vje9/73rTv/cYbb+TNb37zKXNNBRDPpcyPmzZtklu3bp3rZihmoKgZ/M+9Bye5ao5xyaIa3nPVYi5ZVPOcc9l8vHOEr9x9gIcOxqfc/75rl/DO5y1SSXbOAYQQ26SUm+a6HQrFXHK298nZks7jHSOsbolSF/aSLens6Elx8aKa4598GkjmyxwezpIu6gQ9LhbWBXE5BQOpEolcCaQlQBsjPhqiXrwu1RecC+zZs4cVK1bMdTOeVWSzWUKhEPl8niuuuIJvf/vbnHfeecc/8TRgGAb19fUMDAzgdp8548bWrVt5//vfz4MPPjjtMVP97c00Pjnb3VMVzwGKmsF/3rmP7zw4ebaqPuzl316yihetaXzOicRjOb+9mh+/9cLK+kMH4vzrb3Zy2HZp/fLdB/jy3QcAeO0F8/nYDSsIetW/uEKhUIBlucuWdJJ5DadDEPS48HucUyag6Yjn6EsWuHRxbWX//sEMa1pPU3bLKShqBolcmUS2RLaogwAkBL0u8mWdu3YPkinqOByC5qiPWMBDSTN4qnuUkb1ldMMyCoT9LmpCXqoDbmpDPurCXvweJSgVz17e/va3s3v3borFIjfffPOcCUaAVatW8da3vvWMCsbPfvazfOMb3zhlsYxjKEujYk7QDZMv332A/753skXxpeub+egNK6gP++agZecmQ+kin/3T3gkxkGO856pF/OM1S1VmvrMIZWlUKE5fn2yakmRBYyRXZjRfnpCIJux1Ewu4MUxJrqxTKBuUx+03Tdg3mCbqc7O0MUzA4yLodRL0unjqyChXLK0/5e01TMlIrkwiV2I0pyGxxmVel4OaoJeakIfQDKU6NMPk8HCOoUyRkNfFMrvdYAnlkVyZ3tECI7kyqYJGXjOI+FxE/R5cTkF10ENtyEvM71YurnOAsjQq5ooTtTQq0ag4o2w+lOC135kcHPyKja18/IaV52Rc4tlGvqzzmT/u5Udbuibt+96bzueq5ad+0KM4MZRoVChOT59cKBs8cihOc8xPddBD1QmWsrh//zDrWqOEfW4KmkG+pJMrG/QlC3SN5GivsTIUhr1u6sKWoHM7T2xCTkrJUKZERzyHaUqcDkFV0EON3d5nItwyRY39gxnyZYOmqJ8FtcFJiXPyZZ3+VJGhdAnDMMlpBg4BHpfDehbbmlkX9lIb8qoJx9PMnj17WL58+XPem0pxZpFSsnfvXiUap0OJxrkhW9J538+e5O49QxO2X7uigS++ci2xgGeOWvbsJ5kv8/9+vZM/PN0/Yfu1K+r5r1evJ+JTIn0uUKJRoTj1fXJZN3no4DCXLq49qXi+4UyJoUyRVc2TXVAfPZxg/fwYXpcTKSWZks5wpkQiW0Y3LUulx+mgJuSlLuwl6HFOEAFSSvpTRTrjOXJlHa/LQW3IS1XQQ8TnJnDM8c+U8fdDwOL60LTeO7phMpQp0ZcsUNJNQBL2uXA7neRKumWJldAU8zO/OqCyt55iOjo6CIfD1NQ893I1KOYGKSWJRIJMJjOpzqYSjTZKNJ5Z9vSneeFXJgbguhyCn7ztIi5YMHXhUsXpY0dPild/ezP5sjFh++3vupiNberzOJMo0ahQnNo+WTdMHjwQ58KF1RXXzBPl4YNxLlxQjesYy6GUkocPJrhsSe2M55d1k3i2xHCmSCJXJl3U6B0tksyVCXhdtFb5aYz6iPrdVAU8eN0OciWDdEEjXzYqbqkATiEI+VxEfG7CPhchr2tSu2aLZpgcGs4ynClNcl+dCtOUDGdL9IwWKGoGAqgOeXAKwXC2hJTQrATkKUPTNHp6emasMahQnGp8Ph+tra2TYi2VaLRRovHM8NPHjvCRX+2YsO3vLlvAR164/KQ7PcWpQzdMvnDnPr51/+EJ2//jb9bwugvnz1Grnlso0ahQnNo++YH9w6yfHztp74lsSWdvf7pS7mI8fckCBc1gUV3ouNcplHR+93Q/Rc0g5HOxqC5IU9RfibE0pQQJEb+b+oiX2qB3SndUw5RkizrpokamqJMt6RimtISlhLDPTVPMR03Qc0LWqTH31ULZpDHqm9J99ViktERk72iBQtlASolmSgxT4nM7aYr6aKs5/nUUCsXZjxKNNko0nj6klPzXXfv52jGlMm590yauXt4wR61SHI/HOkZ41bc2T9j2+gvn88mbVquECKcRJRoVilPbJ28+lHhGpTAe6xhhTUt0yqyiu/pStMYCx425f+pIkgcPDHPdqkYW1YemFVFj7q2DqSLxbBkpJQioDnpojFiWyJmE4Nj5fUkruQ0S3C671EbEN6sYxPHuq0IIFtUHZ518rpJcJ1kgU9BI5Mrkyjo1AS+L6oO01QRPywSxlJZQNSUIYSWTdQhh/a7cOhWKU4IquaE4bUgp+cTvdvP9Rzor2+rCXn7znktpjvnnrmGKWXHBgmo6P3sD/akCL/ufR+hPFbnt0SPc9ugRXrWplc++bK0SjwqF4lmNZpjohjltGQrdkLic038PlnSDv+waoKiZvOvKRccVTEIIIj43EZ+bJfac6nghtrs/DViCqDbkpTHqIzSufFLl/MajIrasmwykijzVnUQ3TBBQG/LSFPURnsL6KoSgOeanOeavuK/uG8hQFfCwtCE8o/DUDInL6aA+bF27LuxlNK/Rnyrwpx39DOfKeJwO2qqDtNUEcDoFAjHB/fZkcQqB0yGQWG60ErCMtzNfe6b7j98nmPw5jz9v/LFOIfC6nXhdDrwuB76x391OfC6H8qxSPOtQolFxUkgp+divd3Lbo0cq25Y2hPjlOy8h6lfJVc41mqJ+Nn/kGoqawZu/9zibDyf4xdYefrG1h9ecP4//+Js1SjwqFIqzlmciSPb2Z1jeFJl2v26a02ZI7U0WuG/fEAtqgly86OQTmQghqAl5qQl5K9sMUxLPljg0lCVX1gFwOx00hH3UR7z43EdFrsflYH5NgPk1AcASVIlcmY54zqrxCAS8LpqjPmpDR11ix6x3DWEfEZ+b/lSR/9vWTUk3aY5NFJxjgsrtFPjcTvweJwGPk7DPRV3Yx/KmCE6HwOUQZIoaT/ek2DuQxpSwtDHEefOriPqfPYnvDFNS0g1KmklJNylqBpmiTkk3KGpmJUHSeMZEp0DgqYhNB16XE6/90+d24HE6lPVUcdahRKPihPnug4f51B/2VNY3tlXxo7+74KSTDyjOHnxuJz99+0UTxOPPHu/mZ493864rF/Hh65fPdRMVCoXilJIqaKxpnZwxdQzNkLiOmTQzTMm2rlFGc2U2zIuxcoqMq88Up0PQYLucjlHSDYbSJXb1pexMp9b3dmPER33Yi8vpqMRDFjUDv9uJlFDQDEZyJQ4MZkgVNKS0Sn3Uhb00Rv0EPS4CHietVX6WNIRwCsHh4Ryj+TItVX4W1ARPaOLQ53ZyzQof16xowDBMtvek+PWTfTgEzKsK0Fzlp7XKf06PG5wOQcDj4mQSwEspKemW2CxpBiXdJF3QKGolSrpBWZdTToSMJUgKe92E7ARJqiSK4kxx7v63Ks44d+0e5G0/PBp/sqIpwh3vvmTCbKfi2cF48XjzrY/xaMcI37jvEN+47xD/8/rzeNGaprluokKhUFSYyq1wthw/EQwTBFM8W2JHT4oN82Ps6kuzYgYr5anG67KEXW3IS6qgkSpoDKaLbIknGM2XMU2J2+WgrSZIW3WAWMBDU8yJ3+2c9Jxl3aR7NM9gukgyX8aUbqpDnkoyoTWtUaSU9CYLPHIogd/jZEXTzJlXp8LpdHBeWxXntVWRymvsGUizfzBDVyJHwO1EOASNER8tVf6TKpVyLiKEZa31uZ1wAt5ZumGSKxlkShpDmSKHhnU0Y6JF0ykEQa+rknU35HNNeK+mKdFNaSVlwioVozyJFLNBiUbFcemI57jqi/dV1j1OBw//y9XUhb3Tn6R4VuBzO/n5Oy4mXdS4+ov3E8+WePdtTwDw5/ddzvLGMzdYUigUiuk4FfFyx72HlDzdk0I3Jc9bWoeE05aExTAlaVsUpgpaxT11DJ/bSdTvpibkYUFtcIK1qaQb9CeLDKSLDKSKuF0OmqI+GiO+CXF2HpeDRXWhSlbYVF6jM54jU9QRwgpbaK3y01oVoLUqQLaks7svTVEzWVQfpDHiO+FnjwbcXLSwBsOUHBrOMpguEva4cAjB0z0pNN3E6bDiLZuivmdlXOCYW2tZN9HtLLRjiz7hd3PSPlPKSRMkx67rpiX0s0WdTFEjW9LRjHFxmcJyc4743YS8TrwuJ0GvC88s3vXYuR6nA7dLHP3d6cDtFLhdR9dVNt1nH0o0KqZFN0xe/o1H2N6Tqmy78/1XsLQhPIetUswFEZ+brR+7lkPDWa75z/sBuP7LD9IU9XHvB65U1maFQjGnOISgpBsnbKmabQb5omaw+XCClU2Rirto90ielmeQ8E1KSTKvMZQpkSpoE2LgnEIQ8buJ+t0srg8R8DhnLdC8LifttUHaa4OAZVHsSxbY2jWKaVpJbJpjk0VkNOBmbSAGWMKmP1Xgia5RdLu0xvzqABvbqjAlHB7O8uBgnOqgh2WN4WljPqfD6RAsbQiztCHMaK7MvsEMpilZ3BCiKuBhIFVkW9cohm05ba3y0xD2nTUWMSklmiEp6gZFzYprLGpWLGNRNyZY/45NtOMQ4HU78TgduJxWYp+xBD8+t6Oy7nI4cDqtGFGHsH+eouc3TEmurFvlXIo62ZJWcXcew+d2UhfyUhc+Gj9rmhLNNNEMSVk30QyTsm6SL1vCVDNMyoaJppuYs/jXCvtcRP3uSj3Ss+XzVUyNKrmhmJIfb+niY7/eWVn/ymvWc9P6ljlskeJs4u7dg7x1nKvyv754JW+5bMEctujcQpXcUChObZ+cymt0JHKsnxc7ofMMU7K1c4QLF9aQLmrs7c9gHDPa3dmbQjNMVjVHKxY9ieTgUJbLl9TSGPFPm3l1PPmyzkCqyHCmZN1DQMzvoSHiJep3nzGr2piIHEgXZxSR4ymUDY6M5ElkS0igJuShrTpIrqyzfzCDQwiWN4aJnUyAn41umBwczjKcKVEVOCpGS7pB72iBwXQJKSU+O/ayLuR9xlZe07SEX8kWe8WK+LPiDM0Zxsgep8N2MR1LYGP97nM7cTnEOZ/IplA2GM6UGMoUKduC0u1yUB+2hOQzjUc1TUm2rJPKa5V6pGPvW2CJ6KjfTcRvCUu/e/YTJ4qTR9VptFGi8fgMpIpc9Jm/VtavXFbHrTefr2Z/FJOQUvK+nz/Fb57qq2x74INXVbL3KaZHiUaF4tT3yQ/sH+byJbUnNLAsagYPHojjdzsJeJ2sbIpM8JyQUvKdBzt49fnzJmQGl1Jy795hljSEGM6WKGoGYA12YwE3Mb8bzZAMZ0uU7H1+j5PGqI+6kPescrscLyINU+I+joiUUhLPljkykqeoGbjshDrJvOUK2Vrlp/0EE+ccSyJbYv9gFolkZVNkghjNl3V6RgvEsyWQltWuJeanPuydcE/NMMnYLpqZok62pE8SgQ47tnCsZIbP7cBnC0CvS8X6HUtJt4TkcKZEoWz9XTsdgtqwl/qwl5DXdcqEnWZYyYHSRZ1UQSN/jIu23+2sWOMjPrdKCHSKUKLRRonGmfn0H3bznQc7KuuP/MvVqtai4rgMpotc+B9HJxpuWt/MV16zYQ5bdPajRKNCcer75O6RPGXDrMTozYSUko54jgNDWUqawQ1rm6eMwdrWNcpAqsANa5snbB/NlelLFVjVHK2UtxhLKJMrGeRKumUpCViDWY/TQY3t6je+5uJ0jLkB6oZEN47+rhlWHJxuWC6Chinxuh2W6PU4CXhc+NzPrFxDWTfpTxXoT83OEqkZJr2j9vHSJF8ykFg1m1c2R55RchvNMNnVlyZb1FndclQ8GqYkW7IEYTxTpiORs6yg0mpvTdBDfdhLNOAh7HMR9rkJeV0qzu40oBsm8WyZoUyxUt7FKiFjfwZ+9ym3EEopKWomqYJlpUwVtAkuwQ4hCHlt11e/m7BXub7OFiUabZRonJqe0TyXfe7eyvrHX7ySv1OuhooT5Bdbu/nQ/z1dWb//g1fSVhOcwxadvSjRqFCc+j5ZSsmDB+JcsbTuuMfdt3+YxXUhwl4Xvbb4O5YDgxkkkMiWuXhRzYR9R0bybOscocFOBlMT8tAQ8RHxTW1pKekGiWyZ4UyJXElHYtU7dDkclMplnOUMpsuLdPpBCDvhiLXf5bQSjrgc9k97u9uOhyvpJoWyQb5skC/rFDVzUmIggcDlFBPEpd/jnNVgeryIHLNENkV90yaqSRc1Dg/nGEoX6UsVmF8d5MIF1QRnIZbB+nxyZcNK4lLUSRd1cmWNzniegmbQXhMg5vcQ9LqI+CaXnijpBgOpYkX0Oh2CxqiPxqjvOZOdda4xTMlIzhKSqYKGlTXKcseuj3ipDnhOq4gzTUmmpFeSSY25vgY8TtpqglQFTr2QfbagRKONEo2T+dTvd/Pdh45aF7f/2wsmuOAoFCdCUTNY9W9/qcQE3XxxG5+4afUct+rsQ4lGheL09Mm7+9LU2TFX09EzmqeomSyuDxHPlhjJlScleOtPFehLFtnYVsXmQwkuXlSDlJLukQJdIzncTge6YXLZkpkFKoVRSBymnOwjm+ihONKHMzeAuzCMpzBk/SwmENJy9ZMI8IQQngB4gvYSAnfg6O9j2/0xiLVBVbu1+Kus9JbToBkmBc2oCMxcyUqEMl5gBj0u273WM21ikmNFpMvOdtoY9U1KiJMvWxlXt/ckEQiuXFbHwroQumGSLGiM5sqM5icmARIIgl4nIa9lIQz7XHhdlvVUM0x296XJFHVWNUeoCh4/hlI3TAbSlojUdBME1Id9tMRmF4uqODWMT/w0kitXaoUurAtRG/KcERGXLel0JXIk8xoCqI94aa0KqGR+41Ci0UaJxqNkSzqr/+0vlfVP3rSKN17cPncNUjyr+PnjR/jw7Tsq61s/di21IVWiZQwlGhWK09Mn64bJox0jXLq4dtpjxsc+DqaL5Eo6C8e5tKYKGk/3JLlssXXM/fuGCPvd5Eo686sDzK8OIITgkUNxLlk0zX2G9lK4/0t499yOw9SO33BvBGmUEXrxRB95wjWoapsoJMeW6Dxw+2Y8XUpJvmxUxNy0gjLgmWCh1AyT/mSR/lQB3RaRjVEfTVG/ZXHKlxnNlRlIFXjiSJLRXJmmmJ8LFlSzsDZIVdBzwtlXddttNVPUWdkcoXoW4nEM07RiTXtGC1a8qYCaoJeWKv+sXIcVp46SbtARzxHPlHE7BQtqg9SFn3mCo9kgpWQoU+LISJ6ybuJxOZhXFZgUG/tcQ4lGGyUaLf66Z5C/+8HR97D9X19ANKCsi4pTS6aoseaWOyvrX33tBm5c1zzDGc8dlGhUKE5fn/x45wirmiNTZndMZEv0p4qsbolW1oezpUrN2aJmsPlQgssW1zCULdMxnOPgUIaXb2wl7JvYT04SjVJC18OUH/gynsN3WZsQiMY1EG6CcAOEGsf9bIRQg7W4bNFj6KDloJynmEszPDpCKpnEoeXwyALVLo2oq4xTy0MuDskuGO2C0U4oZ2Z+MeFmS1RWtVvCsmYR1C2H2qWzFpSj+TLJvDZBUApp1e4TDlGpQTiSLZPIlXE4LJfERXVBljaE8bqdGKZkZ2+KnX0pfC4HzTE/7bUnV/fxmYjH8c+WyJXpHS2QK1kxedGAm9ZYgIj/1CV2UcxMWTfpiOcYzpRw2QKy/gwJSLAEbPdIgaF0EQlE/W7aa4PPuYkEJRptnuuiUUrJa7+zhS2HRwB41aZWPv+KdXPcKsWznS/8ZS9fv/cQABvmx/jVuy55znfCSjQqFKevT86XdXb1pTm/vXrSvocPxrlwQXUlFs8wJY93jnDRQsv99K7dg8T8bkqGSXPMz4KaII92jEyKaYRxotE0Yc9vMR76Ms7+JwGQLh9i/evh4vdY4uw4SCkrsYkFzai4kRY1A1NamSKdDsjYmSSdDkHY56K9NmiVngDLFXa0wxKQY0IyOfazG2wX2EkIB1QvtARk/YqjP2uWHBWzWIP6ZL7MiC0cxzKRSnnUK9awYwjBqjVZE/IQ9bspaAaD6RKabiLEmCXSS3+qxOF4FtMEn8uqSzivKkBLzH9C1p4x8Zguaqxqjp6UeBxDSkmqoNEzWiBdsKzEPo+T5qifurBXJdM5A5R1k65EjsF0CafDEpANkTMnIMdcabtG8uRKOg4haI5ZLs1nU+bj04ESjTbPZdGYKmis+8RRq88d776EDfOr5rBFiucSu/vSvOirD1bWH/voNdRHZp7ZfjajRKNCcXr75M2HEqybF51gbcyWdPYNpNnYNlFMPnIozkULavjjzn50w+SqZQ0TvG+2HE5wQXv1JBHzyKE4lyysQf/1e3Btvw0A6a9GXPB2uOBtEJzoulrSDfb0Z0gXyvQmC2SKOjG/m8aYD7fDWcmC6nc78Xussg9+txOHoCIkS9rRuMRUQaM/VSRVKAMQC1jZKj0uB26nda1YwE1tyIvPISHde1RIjnRA4gAM7YWRw1MKSulwUQy3k4suoRBbQql6Ke7GVYSalhILB48rnnTDZCRfJpG1ROaYZdLpEEgJJbtch8PhQAjIlXSqg1Ys5VC6BEBzzM+86sCshdqpFI/jyZd1+u0am6YpcTgE9WEvTVEVF3m60QxLQA6kLAHZXhs4Kav0M8EwJX3JAr3JAoYp8XuctFUHqA6emVjMM4kSjTbPVdG4tXOEV3xzc2V9/6deqOrZKM44mmGy6l//QtlOi/29N53PVcvr57hVc4MSjQrF6e2Ti5rB1s5RLltyVLjt7E3RWuWfVID+3n2DIAUFzeCFqxsnDQK3dY2wuiU6KfPmIwfjNO39Pgu2fhLp8iNe8ElY/3rwTKxVmy3p7OxNYZqShXVBukbyGKakvSZAIqvRM2qv1wZoiPgRwioZILAseAIBgsp2j9PKnDq+nVJKhu34rJJu4hBQb1vFEjmtUityLINlbdhDdcBjWU30Erm+PaSP7EAf2E0guZ9g6iDeTBeCKcaIDjfULjlqkaxfAfUroWoBOI4/tihqBiM5S0xmShqGKUnmy2SLVlbZdEGjMerniqW15EoG3aN5pISGiI+2msCs4h9Pl3gcwzCt992XKlC06xVG/G6aor5npZA4W7AEZJ7BdBEhoK0mSHP0zApIsCY4uhJ5RvNlAh4n61pjz5o4SCUabZ6LovFLd+3nK389AMCrN83jc69YO8ctUjzX+c879/G1ew4C8NbLFvCxF6+c4xadeZRoVJxrCCGuB74COIHvSik/O81xLwf+DzhfSjljh3u6++S9A2nCPjctdr3h7d1JljSEJlgfh9JF7niylxvXNzOYLrF+XmzSdbZ3J1lcH5pQMmIgVWTrvb/ihu3vRUgD42X/S2rRjZWMpLmyTiJriTiPy0F7TRCvy7IgGqZJMq+xqC6EBExp1Vs8PJwllddY2hgm4HEhkZgmSCRjQzVTSsq6VaOxElOImPy7hGRBI1PU8DgdNEZ8LKwLEfa5yJd1Dg5nOTycq8TwBb0ultSHWVRnJaYRQoBWgPh+yxo5tBuG98LQHstSORXeCDSuhaa10LTOWmqWgHN2MWG5ks5QpsRgqkjPaJ6dfSkcCJY3h1nbEsXjcjKYLmGYkrqwl/bawHFLaIyPeVzTEj1t+RuklKSLOv2pAiO5Mkhwu6z33hDxqYn604BumHSN5BlIWQJyfnWA5uiJuTWfCuLZEjt6UqxoitAYPfc9qJRotHkuiUYpJVd98T46E3kAvvO3m3j+yoY5bpVCYfHIoTiv+86jADRGfGz+yNXPqZlZJRoV5xJCCCewH3g+0AM8DrxWSrn7mOPCwB8AD/DeuRaNY/UYn7ekDodDsK1rlFXNkUp6/b0DaXIlg6DHSWcix1XL66cUIbv6UrTGAhXBcXAoS37wEKt+fyPOUpLule+gZ+OHqQq6CbidZEo6g6ki9REfyxvDk2KgTFNOGydZ1k229yTRdJMFdUEKZYN0UadsWw8dDoFTWPUZhbBcPZ1C4HAIHML6XQjr2cuGiW5IirpOV7zA3sFMRSTOq/KzoDZIwBbCummSKRikixr5so7L6cDtEIR9blqr/DTFfPjdVukLr1lAxPfbInK3JSoHd0Kmf/KH4PJD42pLQDbaYrJ+Bbhml007ni3xyME4h4ZzeJwCt8tB0OOiPuzD53EgENSFvSysC85ogdQMkx29KYplgzWt0UlJjU4HZd1kMF1kIG2X+gCqQx6aov5p63kqTg7dMOkeLdAzmific7O6JXpGY0+llBXL9sa2qnO6HuhZKxqPN3MphPgScJW9GgDqpZQxe58BjOX0PyKlvPF493uuiMaSbrDsY3+urG/5yDXPitkPxbOL4UyJ8z99d2V95yeue85kKVOiUXEuIYS4GLhFSnmdvf4RACnlZ4457svAXcAHgQ/MtWgEKztq92iB9fNiPNYxwnnzYwgheKxjhMaojwW1QfqSBR4+GOeVm+ZNeY39gxmqgx5qQ14eORRnODHCtY+8kWByL/HGK6h52x0Ip4vOeI4jI3laqvwsrA3OKAru2zfE2tYYqYJGuqCRK+sT9muGSV+ySEvMz3nzY/jcTkx51CppSssKadjrUsrK77miQW8yz0i+jGlaNsigx0XE78LldKAZJkPpEsm8htfloDHqY0l9mNqwh6BthS0bJiXNSnzTNZJnKF203V4FsYB7yqyi7sIwwZFdhEd3ExndTWBkF+70kckP73BbwnHMGtm0DhpWWbUnp0E3TPYOZEhkSzRFfQxlShwYyqIZJtmijhCC+dUB1rZGWVgXmlYwlHSDHT0pNEOytjU6wXp8upHSKnjfnypOSLDTFPVRH/apBDuniES2xK6+NPURL8sawmdUnOdKOk8cGaUp6mNxffj4J5yFnJWicbYzl+OO/3tgg5TyLfZ6VkoZmurY6XguiMZjB+IHP/3CZ32mJ8W5i2FKlvy/P2LaX0MPffgqWqsCM5/0LECJRsW5hBDiFcD1Usq32utvBC6UUr533DHnAf9PSvlyIcR9TCMahRBvB94OMH/+/I1dXdO4Op5CHj2cYFVLlB09Kda2RnisY5QN82OV2MYnu0YZyZW5ZhpvnMPDWRwC/rRrgMW1Ya4Y/hHe+z4J1YvYcu3/cdHKhewbyKCbJquao5POHxMLu/rSJPNlDCnpGy3QFLOycfrdTtxOgSGtY31uq7B90OsiV9LpiOdorQqwqG56IZor6RwazpIu6Pg9TuZXB45bMN00JfmyTs9ogQNDGVJ5HV2aNIR9E0ShUwiCXhdVQQ9elyCRteIRAfweJ61VE++lG0eT9RTTCcz+p3ENbscb30VwZBf+9OFJsZJSONCqFmM2WO6t7pYNOJvXgj82qc17BzLEsyVWNEWoC3splHX2DWbZP5imYzjHaF4j6neztjXK+e3V1IYm190ragbbu5MArJsXm7Pi7oWyQX+qwJCdYEfYGWcboz7CXmWNfCb0JQvsG8ywsDZIW830ExKng854jq6RPBvmx4icAav2qeRsFY2zmrkcd/wjwL9JKe+y15VoPIZdfSlu+OpDACxvDPPn910xxy1SKGbHW77/OPfsHQKeG5l9lWhUnEscTzQKIRzAPcCbpJSdM4nG8ZypPrmsmzzakaj8fvmSukqMmZSSBw/EcTnFxJqL49jbn+KXW3t4y+ULaIkF4Ecvg0N/hVfcytbQVfjcToRggmAs6yb7B9Ps7EmTLmmEfW6W1IcqJRsMU7J/MMvGtiqcDoHLcdTltFg2yZZ1ciWdbEmnpFlujv2pAi0xP7VhL16XE6eARO5o5tTFdaFnHLNX1Aw6EzkS2TJCwLyqAA0RHwXNIJkvM5q33FfH0HSTom6imyYhj9uqb1jlp2amZDClrOXO2r8d2f8Usm87Ir4PYeqTDi2E28jWrCVbs4ZczRpy1atwByJ4nA76kgUKZYO1rTGaYj68LgdCCNJFja5Eju3dKfYPZjBMyarmCO21QWpD3gmiOFfSebonhdspWNM6OdnRmcY0JfFcicFUiUzRska6XQ4awj4aot45b9+5hpSSw/Ec3SN5VjRFaDiDWds1w+SJrlG8bidrW6LnTKKcs1U0HnfmctyxbcAWoFVKKy+0EEIHngJ04LNSyl9Pc58zPqs5F9y1e5C3/dDqfF9/4Xw+/Tdr5rhFCsWJ8fk/7+V/7rPqOX79dedxw9qmOW7R6UOJRsW5xPEmeYUQUeAQkLVPaQRGgBtnEo5nciL3wGCG323v402XLpiQSbMrkQOgN1mYUjSO5Er8970HuWFNk1WqwzThc+1QSsH7d7M57iWZ13jhmiaS+TKdiTx9owW6R/MsqguxrjVK7TQFyh86EOfSxTWztiZJKdnRm2Jr5wixgIeqgIe6sBfNtuyNEfS4Ku60z6QchGFKekcL9CSt7KW1IS9tNYEJVjndMEkWtIqgTBc0hrMlMgWtInaWNYZpqw7gnMnrSSta8ZH9248ug7vAKE18Bwhk7RK0hvUU69aSrlrDk/o84gVBa1WAkG+iu6mUktG8xsGhLKP5MoYpaYn5mV8dIOBx4Xc7aYj6CHqcHBzK4vM4WdMSnVWG1jNFSTcYSpcYTBcp27GRIZ+LxoiPmpCqGzkbTFOyZyDNSK7MmpbopAzKp5PhTImdvSlWNp9Z0XqyzDQ+OVcCiF4D/N+YYLRpk1L2CiEWAvcIIXZIKQ8de6KU8tvAt8HqoM5Mc88s/7ethw/8cjsAn3nZGl57wfw5bpFCceJ86PrlLKwL8YFfbuc9P3mC7tHlvPN5xy+KrVAoTjuPA0uEEAuAXqw++XVjO6WUKaCiuGZraTyTLKwNcmQkT9Q/0RLXlchz+ZJa+pLFSv29MeKZEj9+tIu/vaidkj1YJ77PEoyRVg4UI3jdGoPpIg8fjBP1u2mO+Ujmy7z9ioXHFYMNES+D6dJxcw7kSjoHh7JkijoBr5O/Oa+VvmSBRLZMc8w/QQRLKcmXDRLZMnsH0s9ITDodgvk1AebXBJBSEs+W2dGboqSZhHwuFtQGifqtOpC1ocmJbYqaQc9onj39Ge7ZO4QpJVG/m6aon/qIZfGLBdzWe3L7oOU8axnD0KxsrX1P2ssTiMFdiPh+vPH9ePkFUWCecCLrVzASXUUytpqGZRcRaltXSbYzlhSoaMdoPtYxwvaeJLohqfJ7iARcSCyraUEzuOPJXurDHjbMryLm9xDwOC2B6XES8DjPuKD0upzMqw4wr/po6EamaP3dHRrOIaUEATVBL41Rn0qyMwUOh2BVc/RoQiQtzfp5sQmZlE8XdWEvVy6rY2dvmsPDOTa2VZ2z2XTnUjT2AuOjzlvtbVPxGuA94zdIKXvtn4ftDmoD1kznc4pbH+rg339vhYHe+qZNXL1cZUhVnLu8YmMrrVV+XvPtLXz2T3vJFnU+cN2yuW6WQvGcRkqpCyHeC/wFK3HdrVLKXUKIfwe2Sil/O7ctPD4diRznt1fzVHeSjW1H3d9ddr3D6qCHkXx5gvj52eNH+LvLFiCBI3YmcrqtrM+Zug10xHN43U6aY34uWVSDYUoeODDMpYtrZzVoX1AbrCTkORbNMNnTnyZdsITioroQUY+AYgq0Yap8JXRR4ND+vXQX8iyqchNyGQi9RFAvEjTKzNeLoJdBLyKlSdkZJEOQPhkg7wigeyIYngjRqjqaaqsJzRB7JYSVpbQubL2fTFGjI54jU9RxOQRtNUEaIhMtqj63k8X14UpCECklw9kSh4dydAzn2DeQIexzWe69WLF8E+IpnW67fMda2Hiz/WKKMLTrqJDsfRKG9yAGd1IzuJMafg6PgenwIOtX4mw9D9G8AW/zBrx1K4j6j8a3FTWDPf1pDg5lyZX1ivtqXdjLcLrIY52jOB2C+rAXj8tB0OvC43JUyqBMeD8IfG4HAY+LgMdZEZh+t/O0CLiwz03Y52axXerYNCWJXJnukXwlyY7b5aA+7KUh4puzmM2zDbfTwXnzqyoxrU7HmXFLFsK6T7aks+VwgpYqP4vqTijC7qxgLkXjjDOXYwghlgNVwOZx26qAvJSyJISoBS4FPn9GWn0W8V937eerdg3Gn7/9Ii5cODl9t0JxrnHRwhr+/L7Luf7LD/Lf9x6kqBnPyVqOCsXZhJTyj8Afj9n2r9Mce+WZaNNskVLSmyyyoC6IKSWpgpUoRUqJwBrQt1T5OTiUrYjGAwMZWmIBwj43Rc2gbNiWxu7HAdjjWsHCuhCL60Ps7E2RKmh2jGL1rAegLqcDl9NBoWxULH+mKdnbN0p+YD8rXH0EUwft0hZ7IXEAjPLR84HZTqkJwGsvU0VuSuFE80TQ3WGkL4o7EMMVjCF8UfDFrBqMgWqItUFVG+HoPNa2xgArfvPISI5Dh7IIoDHqY351YFISPiEE9WErUyhAKq9xOJ4lXzZwO61Pons0T7rfEj0OIagNeaiPjEsK4/ZBy0ZrGaOch4EdFWskfU8i4gdwDDwFA0+Ne+E+q+xH8wZo3oCv5Tw2tC5hw/wqciWdA0NZhjMluhJ5wj4Xq1uiSAmZojWZEPK6GM1rSClxOgRNUasUidvpQEpJUTPJl3XyZYORXJmeUSsZ0IT3bItNl8MxQVyOic2TtWI6HBNF/djnMpQpsqvPsg4jLGtzY9RH7XPcrdXndnLhwhoyRY2tnaOEfS5WNZ/+Mh0hr4srltbREc9x//5hLmivfkYu5GeaORONJzBz+RrgZ3Ji8OUK4FtCCBNwYMU0Tpl19dnKJ3+/m/99qAOA3//9ZaxumZyxTaE4V1neGOHuf3oe1/7X/Xz3oQ6KusGnXqridBUKxYnTm7QSyORKljXpiSOjXLm0Dt2UuJzWIDFkZyoFa7C9eyDNmtYIYFknNN3ENCWlw4/gBzZceh3uestS0FYT4PBwDsOUk9xfZ0RKVnuH6H3kTywWveR6diCH9rEi24EYJw4n4K+yxI/LC06v9dPlBZcP0+khozkp4yIcCuHz+e1jPYCAUgZKactaWVmsdaEXcJdGcZdGj0amHo9gHcTm44m1sTg2n8Wx+ZjR+QxnGtk2Uo3u9BILuK16kFO4AUYD7krSs0LZ4HA8SzKv4XIK2moC1IW8jOTKdMXzZEqWkHQKQa1tPauUaPIEYP6F1mIjimkYeBqteyuZQ48TSOzAl+mCnsesZQxvBJo3EGzdxPqWTTB/EylnvVWLs6zjFIKakI/+VJG+ZIEVTREuXVSDCQykijx5JIlumDgcgsaIj6aYFWd4PHTDJG9nmLXcifMUNAPdmBxFJQT43U6CXid+j4ugLTY9TseMVkyPy0FrVWBCRvJsSWcgVaQjnsM0LbfWmN9DQ8RLVcBzziRrOVWEfW4uXVxLIlvi4YNx2muCzK85/RncF9QGaYr6eLxzhMuX1J32+50q5rRO45nm2ZI99Qt/2cvX77U8ce/+p+exuP7cM3ErFLOhK5HjeV+4D4BXbmzlC69cN7cNOkWoRDgKxZnrkx/YP8zlS2rpGS0AlktqIltmYV2Q/YNZ1s+LAfDIoTgXLajh8c4RdNNk/byqSh2/PzzdR9AtufLnK5EIxMeGbDFm8fDBOEIwbQbWCZTzsOOX8Ph3YeDpqY+JzoO65VC/3PpZtwLqloL3+LXfdMNkT3+GZKHM8sbIBOvT9CeVLAFZSkMxOUFQavlRcqkRSskBvNkevLkefLk+hKnNfM1QA3p4Hml/Mzl/CzI6j7p5S/HXL4RoayXm8Fgsy2WewXQRATTH/MyrDuB0CHTDJJ4tM5guVkS+y2m5YTZGp3fDLGoGuw51EYjvYLF+APfgU9D7BKSniIqKzYeWTdC6iXTNOvY7FlKUHqqCbkZzVlxnddDL6uYIC+osQawbJoOZEn3JAppuWlbViJeWmP8Zu4aapqSgGeTKOoWyQa5kUNB0yvrR8fuYBXPMTTboddlC07JgjmWWPRYpJcm8xmCmyGhOq1ynOuihPuyjaizm9DnCk0dGqQp4aK89MyU69g1kCHicE+JV55pnQyIchc037jtUEYz3/PPzWHgO+kQrFLOlrSbIQx++iss+dy+/3NZD2OfmX1+iXFUVCsXsGR+3eHAoy7p5MY4k8iSyZTzj3AEbIj72DKTxup0YJUnQa4mBxzpGSBU0Xriq1RKMSHBMFAKmKY+f3CJ+AB7/X3jqJ1YyHUDzRMnUrseoWUbdwvW2QJydOJz+eR2saY1imJI9/Wn29KdZ3himfqbMjS4vhOqs5RjcQGzcum6Y9KcLxPu7EMkjeLM9xLR+YqV+PJluSB6BVA9kB3FlB6kGqo+5phROZM0SHE1roGE1NK6GhjUQbsDjcrC43nL9NU1Jb7LAox0JTNNKKtJeG5gQB6oZJkMZq6B7yU78E/LZbphBq0ajz+1k4/KFFMptbOtJ4mgTrG2N4isMQe9W6NkKvdssIZk8Yi27fkUE2ORwIRtWU6jfgDe0Cn/1OkqRNg4OZzgcz1EVcONxOWmrCbCprQohrJIqw5nSBNfQupCXlir/CSdfcTisOpljExgzMeYmOyYwhzJF8mWDkmZOiMN0CEHI6yLscxHxuVlUF8LdeLQMzWjeSrSzdyANWGK0OmhZJKP+Z6+Q3DC/iieOjEKcMyIclzaEuG//MM0x/znhLqwsjecQP9zcyb/+ZhcAf/rHy1nRFJnjFikUZ4ae0TyXfe5eAD50/TLefeXiOW7RM0NZGhWKM9cnP3IoziWLapFSsvlwgksW1aIbJr/f0c+qpghLGiyBVtR0fri5i7detpAthxNcvKiGhw7GWTcvxs7eFPOqArR8YxEOLQ8f6Zkg7J7uSZLIlrlqef3Emxs67PujZVXsuL+yOVO7geEVb6D10tfh8QUq1tDTMRg3TcnegQzxbImlDeHjZms9UaSUjOTK9CYLZIuW9a8u6GKeO4Uv23NUhCWPQLILkl3IVA9CmpMvFqyDxjEhaf+sXQJOKwZ1OFOiI55DMyQRv4tFdaEpxVSmqDGQKhLPlq3YVTuRT1PUR9B2RR6rz7i6JXrUGmgaVgxpz1ZbTG6D4T1wTFtNb5RU9RoGw2sYqVpD/fJLkIEahjKWW3Fd2Mv86qPlSUxTEs+W6EkWKNpxjtUhj1UmZBZi8FRjmpJsWSdT1EkXNDJFHd2c+Ixel5OIz0XE7ybocVLQDIYyJVIFDaQVo1obsiySleRFzxKeODJKTdBTSZp0OklkSxwZyZ819amVpfFZwB1P9lQE46/fc6kSjIrnFK1VAe58/xW84EsP8Pk/76Mm6OHV56vSMgqFYvaMH9S6nA7aawJ0JnIV0dgRz9MY8SEEIODJ7iSL60NE7KyiXYk8re4AaHnQChNEY3tNgCePJI/ezDTgka/Bo9+CTJ99Uz9yzSt5ouFlLF1/GQvHZSttrwnSmciz4DRYNxwOwcrmCKYp2T+UYf9ghvaaIPOq/adkoC+EoCbkrcTyjYm7XaOSkr4MEV5OY6uPlpi/Yo0V5bwlxgZ2Uup9mnLvdvwje3DlhuHQPdYyhtMDdcsRjWuob1hNfeMaaF1NSgbZN5ghX7ISCS2qC1bq741lF11iJ5Q3bNF2YChL3nZr9XksUfR45whBr4u1LVFcTic0rLKWsYytpQz0PTXBIunI9FPV/xBV/Q9ZxzwKaV8rdS0biSy+mKSxlp3ZhZSkG5/bQVtNkLqwt2LtldLKdnpoKGu52QpoivpprfKfkZIeDocg4nMT8blpifkn7ZdSUtJN0kVLUPaniuTL+tEDhOUSO5AucmQkj2lK/B4XLucUyYvOQc6bX8W2rlEE4rTHONaEvHZJHY3wDBmMzwaUaDwH2HI4wft/btVh/OnbLqrEXygUzyWWNoS5/V2X8PJvPMKHb99BLODhulWNc90shUJxljOWIfVYqgIeekcLpAoaXpeDkVyZhogP3XaJXNsSoylqDahLmkHY50a47QGklp9wrYjfg5SSbEknJEpw+1stCyNAzRI4/62w7jU8OSxpjfknDQ5bq3z8cccAPreD+rDvtLiqORyC5Y0RljVIOhN5HjgQpynqY3Fd6JQmQLHi+XwVgWSYlrjY3pNE001cTgfNMR9NTefhbNmId6OV1RUpSfUdZPjgNtzx3VRl9hFK7sWR7LRiP4+J/4xGWjmvcTU0rKZUu5LOwnJ2Oupxuxy01wapDx8tAeJ0CBoivgnF1fNlKymM2+lgOF3kO4cTLK4Pc3571UQXTG8YFlxuLWOkem0R+bhljex/ikixBw71wKHfUA1UOT2IpnVoLRcyENvAY5H1GN4YjVEf86oDE+pbmqakP11kW9cohikJ+1y01wYrExZnGiEsl16f20n9NJ7ShinJFvWKsEwXNXTdZN9ghqeOJPG4HEQDbnwuJzUhK+Z0LqyqJ8vGtiq2dY0AnHbhuGF+FY92JM76pDjKPfUsZ3wikK+/7jxuWNs0tw1SKOaYe/cO8ebvW2nvz9XMwco9VaE48+6pAFs7Ryp12Q4OZQh5XewZyBBwO1nbGiOeLTGYLvJ0b4q3XLqgco0fbu7kbza0EP7fyyz3xXdvgfoVE+5zz55BakSSdQ+80yr94IvB33wLll4HQtAZz5EvG6xsPuoplClq7Oix4htH8mUaoz40XSKlxO1y0BT10RjxTSpfcaroTxU4OJQl5vewvCl8RqxcZd2kP1WgP1XENCVet5Xlsy7knSBeE9kSh4ZzGIUUTaXDtJQO4R7eZZXXGNwNemHyxUONGK3nM1K1nv7IWnI1q2itraIl5j+uMDZNydO9SZ46kqQ+7CUW8OB1O2iO+Y8v5A0dhnZD71Zkz1aKnY/hSx604l/HIetWkG88n/7oBkbrNuGuns+CmiDRwERxmCpodCWsOphOh2BedYCmiO+cyW6aL+sMZ0oMZ0oUygbpgkaqqONxCaoCHqoCbppm817PArZ2jtAQ8Z32ZDUHBjN4Xc4zkr11JmYanyjReBaTLmqsveVOAP75+Uv5+2uWzHGLFIqzg58/foQP374DgG0fu3ZWKc7PJpRoVCjOrGi8eGENQggODWcrtep296VpifnJazp/3TPEGy5qI13U+N8HO7hwQTUXL7LOkVLynQcP8/YrFsG3r7TqAb71HmjdOOE+e3Y8Tvufb8af67XqGb7+/6ykNlg1CXf1pyZlV93aOVKJqRtLunPJYuuYkm7QnyzSnypimJLGqI+2msBpEXYjuTJ7+tP43A5WNUdPOONnSbeyeuZKOrmyTq6kU9KtGLljLb3jM30ClA2D4UyJZN6KlfN6nDSEvYR9LqwKk1Ztzd5kAcOQxAIemsJuQvlugqN7CIzuITi6m3D8KVyl5MR7OT3ka1aTiK0jU38e/oUXM69t0Yzv0DQlu/rSpIsaK5rCVnbRdAkpZaW0xkyZWiv3LiTp2fkA+QMPUTuyjaqRp3GYE0upmJF5pOs3Ea/ZSLbhAmraVtNcFZggpDTDpGe0QH+qgJRWZtP2muA5Vd8PrMmCRK7EULpEIltiJFcmVdQJeZ3EAh4W1ARomsIKfzbweOcIjadZOEopuW//MFcsqZtTIa1iGs9BdMOsCMbrVjUowahQjOPV589ne0+Knzx6hI2fupsDn37hGZkhVygU5x5el5OSbuJzO6kJeuhLFmmM+jClRDjA53LicghGsiWe6kmyYX6MiN9NpqQT8bnpGS1U3AiZxj2VzodY9vvX4SilKDVswPvGX0DISopT1k2eODLKFUsnu56NtQusOEu3y0GhbMXoeV1O2muDtNcGkdJy8dzaabkvNkS8tNcGT9n3XnXQw6WLa8mWdJ7qTiIlrG6J4HM7yRZ1slOIwYnv2CrzEPS4qA/7CNZa7T8ZsiWd7pE8o7kyIKkKeljbGiPodVXiJQ/Hc+ScCwi1LKeh9g24HIKyblAaPoDsfgxH92O4+rfiTuwjOPQEwaEnYP/34CHI+JroiqwlWbMBMf8CyrUr8XqtGLywz03I52JVc4SyYfJUt+VmeX57FS6no1JaY2dvirL9HmpCXppjvkliR/hjzDv/RsyNL2H/UIadIyma83tx9zxKdPhxovEncKS7iaW7iR28AwDDV02qbhOpuk2Y8y+mcdkFBP0+FtQGWWD/HSRyZXb3pyhqJl6XFS9ZG/Kc9fGDHpeDpqi/4vINlkAfyVslVA4OZ3m0Y4SiZhDwuGiI+ljWEKI5Fphza+Smtiq2do0iBBPqXp5KhBCsa42xvSfJeWdJUpxjUZbGs5T2f/kDALUhL1s/du0ct0ahODu56ov30RHPAdD52RvmuDWzR1kaFYoz1yfv6U/TGPFRFfRgmpJHO0a4eFEN/akChbJBsqCxuC7IDzd38caL2zg4lCPic1VcxR7vtAayly+pgx+/Ag7eBa/7heV2CrDzdrjjnWCUSbRey75Lv8wlK+YBlvXgwQNxNrZVTcryOT6b6xjZks6+gTQb244tUjHxvMF0ic5EDt2Q1Ee8tNcEj1/yYxZkilqlkH1nPIduSlY1R2itCthlH45fVP5UMlb+oSuRo1A2EELQHPPRHPPjcggG01Y2VcOUzKv2M786MLFthaQVe9j9OHQ/apXVKKUn3MNw+sjVrsVsuYBS00bisXVknDHGhseZosah4SwtVX6WN4SJ+D2EfC4CbidCQCJXpm9c5tiQz0VzzE9NcKKQGyuBksxrLG8KM5opkO3eQXViK03JJ/H0PgrZgYltcwVI126g3HwhseXPw9t+AXiOipaiZtCVyBPPlhBAQ9TH/OrTY40+U0gpSRd1jozkOTCYYSRXxu20XLXb59AaKaXk8c5RmmO+0yYcAR7rGGF5U3gu41mVeyqcO6LxnT/axp93WV8cHZ950Vk/e6RQzCVjEyyrmiP84R8uP87RZwdKNCoUZ65PThc1Dg5lK7P3YzGOumGy1U48sqA2SGciR8Tnpj7ipS9ZxCFgbWuMzYcSSCktt9Ffvwee+jG86Itwwdsg2Q1fOw+MMlz4Th5e9E+43S5Wt0QJeFwMZYqM5Mosb5w64/n4eMsxHjoQ5+JFNbOyrkgpGbLLUJyogDRNSTxXoi9ZrGQUDXqPCh6HQ6AbJnsHrIH7wrogLbFTk3H1ZDFMSV+yQF+ygGFKvG4n86r91AY99IxamTy9bgfLGqcZdI+V1Oh+zFp6HoPEwcn3iS3A2XYRzL8YFl2NjLZyYCjLnv40rVUB3E5BvmxUhKVE4hSCqqAHt1NQKJsk85YrqsfloCnmpyHsxeV0oBkmT/dYlsr182IIAfsHM6TzGjVaH4sKT+Pp3QJdm2Hk0MTmO9wUa9fgWXgprgWXwrwLIWBNMJh2wqHOhDWRuqwhfM6FbkxHtqTTEc9yJJFnJFfG73FSF/IR9rtoivqoC3lPW9zveMYmgS5YUH3CLtyzpaybbDmcmNIz4Uyg3FPPIW7f1lMRjLs+cZ0SjArFcdj/qRey9GN/Yldfmu88cJi3XbFwrpukUCjOIiI+N9miXqnXN5abxOV0UCjrRPxuDg1nuXRRLY93juB1+skWtQlJR5wOq2C7s2GVtWFwp/XzgS9YgnHVy+CFn2NeIk+urLGnP8PGtir6k0UW1p1YGY3F9SEODmVZ1jhN2spxCHE0K+iYgHziyOiUArKkGwykigymS+jG0YLzi+tD02a1dDkdrG6JYpqSw/EcDx2ME/A4WdYYmZNMmGNJYcZiywplg+7RPAcHs0gsN9v6sJfDwzkyRY2GiI+FtcGjgsIxrqTGpjdb23IJKwtq96PQ8ziydxvOZAckO2D7TwEQNUtYuvgaFi+4it3mGtKal/XzYwQ8R9+BYUpG82US2TKZosZYKGdBM9g/kGFXb4qA24nT6aAl5qc66GF7TxKXQ7C2NYbH5SBViPH04DwK0eupv9DHQn8Wd8+jcGQzdD2CY3AngaEnYOgJ2PI1AMzGdTgWX4Nj0dU0z7uQ5lgtZd1k/2CG3f1p6sM+FtUFz4ioOl2EvC7WtMRY0xKriOOe0QKjuTI9IwV8bgdBr9PK3Bv20VrlPy2iTgjBmpYoB4eypy0Jn8dlZRfuSuTOSJ3IE0FZGs8iDg5lufa/rOK/f/yHyydkWFMoFNPTPZLn8s/fC5wb/zvK0qhQnNk+uTOewyGsmmtPHBllRWMEv8fJzx47wvnt1WRKOuvnxdANkwcPxHE5rTQtly2pY/OhBD63g+WNEfw9D8EPb4TW8+Fl34H/3mQVfn/PY1C7BNO0XE5NKblscS2bDyUqiW2mYipLI8AD+4efkaVhTEAeHs7SmyyiGSZt1QHm1wRoiPiekftirqSzbzBDrqTTGPGxsC405zFnYD1zMq/RNZInX9IRAlwOBwVNx+10sqQhdDQ2dSYMzZoU6H4M49D90HE/Ti179D4ON+a8i+ipvojCvOexZN0lOJ3TCxTdMBnNa4zkyozmy2iGSSJbZiRXJuh1Uh30IIHGiI9VzVGcDlGJ3Tw0nMOUknlVAVqr/DjKacvV9sgj0LUZ2bsNYZSOts0dRCy4HBZdbS01ixnMlDg4lMXpEKxojEzK1Hquky/rdCWsGFhTSlwOgQlICQ4haIpa7synwn17jAcPDJ/W8hhSSh46GJ+TEhzKPdXmbBaNJd1g2cf+DMAnX7qaN17UNsctUijOLe54sqdSz3TvJ68/ba4jpwIlGhWKM9snW25lw2xsq+bQcJZkXqMq4OF323vxe5wVdzOnw0G2qLGjN4XH6eDiRTXsG8gS8buYV+2niix131iBdAfRl92Ae+cvkOtei/ibb1butflQgpqQB7/bSfdI/riicSyz63j2D2YI+1w0Rf1IKemI5+hNFnA5jg58hQC/20lrlWW1Gn+Nsm6ydyBNqqAxvzqA1+WgM5HHMCWtVX7mVQWecfmGseQ8HcM5ELCkPkxd+OxxhzRMSX+qQO9ogaJmMpQt4nM5aK8JsrQxPPtEPYYGPVvRD9yNtv+v+Ia3I+TRZEBlbzWl+c8jtPL5iMXXQHh29YN1w2QkX6YrnmPfYJaBVJGBVIH22iDPX9FAQ9RH1O9GSugezdM9UsDjcrCsIXxU+GkF6HoYefAejIN/xRXfO/Em0fmw6CpYdDXFeZezL+UkVdBojvlZWBs8Z0p4zJaxyZIjI3nKuonbKfC6HRTLJrppCcrmmJ+m6DMrY7O9O0n7FKVSTiWbDyW4eFHNabv+dCjRaHM2i8axuKwLF1Tz83dcPMetUSjOTd78vce4d98wcHYnxlGiUaE4fX1ySTc4MJglXdQmbD8wmGVpQ4hYwENnPMdFC6vZfCjBaF7j1efPw5ASw5TopmT7kVF29KXZ2FbFcLpExO8m6HUR9btp+8FG3DkrjEQKF0/edDfFsJX4RiAYyZXIlKw6dTG/m0X1IcCyermdAo/LgdflwON00pHI0RDx0hKz3OnGLICmKXnkUIIVTWF29KZoq7GyZ47HNCV5zeBIIs9ovowQEPW5SRY0HEKwoilMLOCZdE7PaIHu0TwOIVhUH6Q+7OOZohkmB4eyxLMlIj43yxrDZ93EXVEz6B7Jczieo3skj9/j5KIFNSysC55YKFB+BO3gveR234X/yH148/0T99evsoTa4musmEi3f+rrTEFZN3m0I8FDB+L43E6aYj4awj78Hie1IS9Rv4u+ZJF0UaMu7GVxXWii+En3IQ/dQ3Hv3bg678ddGjm6TzigZSNy4VXEGy9nn3MpXq+H5Y3hs7LMxamgqBkcGcnTlyzQXhOkOeajP1Ws1Ah1uyxX4YbIidWLLJQNdvalOL99+oRVzxQlGueYs1U0/ued+/jaPVYg9tk80FUozgXGJmD+ZkMLX3r1+rltzDQo0ahQnNo+eSyj6KFhyw1vaUOY6uBEwZQv6+zuS7OpvZpHDsZpqfKzqzeFx+Xg2pWNk6739XsPsqo5gs9tJduwYo38RzOoApx3M9z41UnnPnwwwXCmyHnzq2izxZ5umGiGpKyblAyDsm6SKVolLlY3RynqBppx1IJ1/74h6sM+ljdFcAhLbPrcDnxuJ363s/LT4xT0pYocHs5S0EwCHidOh1VEfUHt9PX8yrrJ4XiWeMZKLLK0IXRKxEMqr7F/KENJM5lXfWqsmqeasdIVjxxM0JfKEwt4uHJpHY3R2Qs8+0JoQ/tI7vgzjsP3Eh3cgssoHt3v8kHbpUfdRetXWCbiWbTv0HCWXX1pAnb5laJm4HFZEw8CQaaoky/rVAU8rGyOUB85RvybJrJ/O5lddyIP/ZXw0DYcUj+63xvBaLuC3tqLGai9hPr5y2irCTwrc2lIKelM5OlK5FjWGK6U/ShqBn3JAgPpIlKCz+1kXpWfurD3uO/hwQPDXLa49rS9LyUa55izUTTuG8hw3ZcfAGDrx66dnb+9QqGYllxJZ9W//QWAX737krOy3pESjQrFqemTTVOysy9FqjBF0pMpeOhAnEsW1bDlcAJDSqQJLqeY0oV0Z2+SP+0Y4LIltbTVBCnrJu21QfjZ62Hv762D3rcTYvMmnbuta4ShdInakJfzF8xsjXj4YJxLj7n/aK7Mrr4Ufo+LjW1VSCkp6SYlzaSgGRQ1g0xRY99ghkSuTF3QS0N03EBXQqakM5i2BEzI62JBrZX9NOB14XM5JrynXEln/2CGXMmgKuhmcX3opOssjiGlpHukwJGRPB6Xo2LlPRsZTBW4b/8wo3nLdfOiBdWzEg7HopcK9Oy4j+TTf2Z+cgvV6WPcRcNNlnhc/mLrp3tmK69pSvYOZIhnSyxpCJEu6MSzVgxjddBygR7Oljg0lCWV14gF3WycX8W8msCkz08W0yR23Yu2/y5ifQ/hz3RM2K/FFjJcfwmF+c9j/nnX4Q6cnkQvc4mUkv2DWQbTRVY2RyaNuQtlg57RPMOZEhIrm/C8Kdy/AQ4OZQh6XRPqTp5KlGicY8420WiYkkUf/SMAX371el66oWWOW6RQPDu4d+8Qb/7+4wAc+PQLz7qaVUo0KhSnpk/e2ZuiKuihJTa7gVtv0qrNWNQMHutI8OJ1zRxJ5FndEp3kTlnWTb51/0HCPjcvXtfMSK7M0oYwfO9F0PWwddAtqSnvkyvp/OapXhoiPq5aVj+jpe3RwwnOa6uqfE9JKblv/zBXLKnjkUPxKa0ZA6kiewbSrG2JzlhWwTAlRc0gmS9zaDhHf6pAWTcJel3Uhry4nJPblS5o9CaLuByC9tqg7b7owudynrTFsKhZLsPJQpmqgIfF9aGzzn0Vjlr4HusYpVA2aK8JsLIlQmPEd8ICsnskz7bd+1iS2Urd8MNUDzyMKz909ABPGJZdDytvgsXXzujGqhsmO3pTFMoGa+fFCLidDGaKHEnk0QxJwOtkYW2Qkm7yWMcIw5kiVQErk2zA66Klyk9d6KgINk3JwJH9FPbcSaz/IaoGHrGS7NiYwkWpaRO+FdchVt4ENYtO7EWe5YyvmbmmJTptbGK2pNMzmmckW0YC86uthERCWOVoHusYmTFm+ZlwNopGVXJjDrnsc/cAsLwxrASjQnEKuWp5PRcsqOaxjhHO++Rd7LjlurlukkKhOMWUdINkXjuh1PfNUR/37R9mdXOEgVSR+rCPsm4ymC5OSm/vcTlYVBfi6Z4U2aJGWbddRz3HT4Mf9Lrwe1wEPU4Ox7Msrp++fEZrdYCe0UIlZnFXX5oVjRGcDkFbdZCuRN6ycGIN9p/stso0XLm07rhCxukQBL0ugl4XLXZB8jFX3iMjeTTDxO9xsqAmSJXtzqsbljWzUDboTOS5c9cA6aKO3+1kQW1wSrHndgr8HidBj4uA10nI68Lvdlba53M7WdNqfU6juTI7elOUNJOGiJcFx7EOn0mEECyuD7O4PkxRM9jVm+KB/VacfGvMKvXRUuWfVfzbvOoA9RetZWvnPDwbXoPmdRI/9ATR7nto6L0Tf3wH7PiltbiDsPQ6S0AueQF4JhaPdzkdbJhfRVEz2NGbwjAl61pjNC20hGa2pNMxnKskubl8SS3JvEbPaIFsSad3tMCBwSwCaIz6mFcdoLl9GbQvwzDfS3ciTergo1T1P0Rj/BHc/dvw922Bvi3w109A4xqrbStfCrVLTvVrP+M4HYLVLVE0W4wXNYO1rbFJZWRCXlelxqppSrpG8jx8MIHH5WCJHatsmPKsyB58JlCWxjnizzv7eeePnwCg4zMvelb6kCsUc4mUkgUfsSz5Z1tGYmVpVCieeZ/86OEEq1qiJ1wvcDBdZCBZ4JdPdPOpl65FM0y2dY1y0cLJs/q7+lLctWuAFU1RqoNuzl9QAz95Dez/k3XAvxwB39Si9eBQll29SaqC3hnLZxim5NGOBJcsqiVX0nm6J1WxMIxPvZ/KazxxZJQ1rdFTGsqSLel0xi3BIYD6iJfWqsAkcTiSK9MRz1K04yYX1oXs7J4SzZAUyga5shVnly1ZonMqAh4nQa8Vj5nXDAZTRYQQR8tKnIUD8P5UgX39Gcq2yHbY9THbagKz8mQ5NGxlR93UXoXH6SCRK9N/eDfhjj9S1/0XgvHtRw92B2DJ820BeR14Q5Ouly/rbO9O4XYK1rRGJ7ii5ko6B4ayZIoaYZ+b1pif7tE82ZJOXciL3+ukP1nEMCVRv5v22mDlf2isvmM6GWd+8nGa+v8K+/6EU8scvXn9SltA3gR1y2cVo3m2MybGpYS1rZO9DqY6/sBglkPDGTwuJ1cvrz/llvOz0dKoROMcML68xp/+8XJWNJ3dNeUUinOV8fUbn77lBUTOkgxxSjQqFM+8T34mtQwf2D/Mn3f28x8vWwtYcYUXLqieZPEqagaf/sMe3v/8JdzxZC9/d9lC+MalVh0/gDf8ysqSOQVSSr59/2EuXVJLs13MfToeORjnksW1bOsaYUVTZELR+Ce6RjAl6KZkU1vVabXKmaZkOFuieyRPSTenLVEwZtlKFzXcTgfttYEJ7o8zXb+g2eKyNCYyDUq6wXCmRDxjZYFtjPpojHgJet0TrJdel2NOJ9kT2RJ7BzJ4XQ5qQ14G0pb4qg56prXCjpEv6zzeOcri+tAEd+pMUaP78F78B/9A3ZE/EYo/dfQkl89yXV35UssS6Zs4XswUNXb0pPB7nKxuiU4SsKmCxsGhLIWyQdTvIuJ30ztasC2qITxOB4fjWfJlK8lOW3WgEss5lClycDCLwyyzMLMVc+cd1PX+FWd5nEt27dKjArJh9TkvIMcmbTwuBxvmxY47gSGl5C+7BqgOeinrJi1Vftqqn3niJ9OUPNY5MuVE1ulGuaeeZZz/qbsBuG5VgxKMCsVpZF51gLdetoDvPtTB2lvuVNmJFYpnEU6HwDTlSQ3QFtYGSBe0yvnLG8Ps6c9UXCjH8LmdeFwCU0LU7+bQUIZFI+MSiHQ+OK1oFMKqEdcS87NnIM0li6aPffK4HBQ1g0LZnCAYi5pBIlempJm8eF3zCT/nieJwWBa0BjsTp2aY9CULPN45iiklfo+TeVUBakOeyrsq6Qad8bzl/ihgXlWA5qgPXUqKmknRTtwz/ndTgsQyWnhdTqoDXlpjAQIeJ26nYCBdZCBVIlXQaYz6KOpW6YSSZrkIj50L4HE6CHpdhLwuwj7r5+kS1jUhL5cu9pIpauzsTSOEZZkq6ZabY1k3CftcLKoLETzGAh7wuLhiSS27+9P0jhbY2FaF0yEI+9ysXLkGVq6hqH2Qg537cez9PbVH/khk+Akr6dLe34PTa/2trbwJlr0QfFHCPjeXLK4lmS+z5XCCmN/KpDrmLhn1u9nYZiWDG82VOTicxZCSmM9FXzJPuqgT83vY2GaNRY+M5DkwZLmxNsX8nL+gGilh/+DzGAlfzH69RLh/MyuS9+I7+EeI74cHvmAt1YuOCsimdeekgAx6XVy8qIZEtsTD08QTj0cIQcTn5vx26x33jBbYfDiBwxblJ1u3tGyYZ10uBlCWxjPO75/u470/eRJQbqkKxZlirAzH51+xlldtmpzp8EyjLI0KxTPvk48k8gDMrwkc58jJ7OpLcefOAa5YVl8ZVD+w30qhf6wI/d7DHbTXBPC6nbjzcc6//cKjO1s2wtvumfY+jx5OUDJM3A4H57XFps1I2jOaJ54p4XY5WNVsibGxmoIXLqhma+colyyqmXPXzXxZp3ukQH+qwGi+jG5IqoLuitA1TMlwpkQiW8blFHbMYoiI343PZZUL8Y7L3DqWFbaoGeTL1lIoGxQ0A900KeuWaM2UdPwuJy1VfmIBD3UhL412GZSybpIr6WRLOpmi9VM3LXEpEEgkTmHFdo6JypDP9Yyzw4Il6nf2pijpJiubIlQFPaTyWsV65/c4WVwfmuTlMhtXY90w6e8+jLbz19Qc+TORoa2IMbHscFvZV1feBMtfBH7rb3g4U2JPf5q6sJdlDeEp/16klMSzZQ4NZ9EMk4DbSdGO122rCdAS8yMl9KeLdI/kK26si+pCpIsa+wcydI7kaA45udyzH8++38Ke30M+fvQmsbajMZAt552TAnI4U+LAYIaLF9XMOFZ/5FB80oRQWTc5NGzVLQ15XSxrDE+YDDoe2ZLO4eEsa1tjJ9v8k0a5p9rMtWjUDJMl/8+Kg7jz/VdYWdgUCsVppyuR43lfuA+AvZ+8fs6z9inRqFA88z7ZNCWbDycmlauYDQ/sH8btFOwfzPLaC+bjcTnoSxbIlXSWHNM3P9aR4Ikjo6xtjXGB8wCu71+PrF2KGDkM0oQPd04b1ziQKvLAgWGuWV5Pb7Iw7SBQM0x+8ugRXn3+PHxuJ/sHM5R1k1XNEYQQlayvi+snx7edbgxTEs+WGEgVyZWsOn8el4O6kBeP28FQumRtF+B1OagL+agLe/G5HQxnSxxJWK6uPreDtpogNVOUL5gN2ZLO/oE0yYJWqaknAATUhrw0x/zTxrcapiRrC8tsUSdb0ijp5oRjBIKg12mJS1tYjk/mMxOaYbK7L026qLG0IVyx1GZLOgeHsuRKOkGvi8X1oUobx5IaOR2Cda3RGe8jpWSor4vC9juIdf2J6NDjCGm33+GCxc+HjW+yYiEdTvpTBfYPZmmJ+VlUF5z22mNJkTriuUqNUCklIZ+LZY2RSluT+TIHh6x41gV1QWqCbp7qTvJEV5LF9SGuXlqNq2cL7P4N7P4t5MZliY3OgxU3wqqXQssmcJx9FrTpGEgV6UxYEzfTvcOpRON40kWNA4MZ8mWDxohvVomfkvkyfUmrLMiZRolGm7kWjdd/+QH2DmS4alkd33vzBXPWDoXiucj7f/4UdzzZS9jrYscn5jabqhKNCsWp6ZM3H0qwqb3qhF257niihwsWVLOnP03Y5+ZCO3bogf3DXL5koktaX7LATx87wob5Ma4u3Qd3vJ2R9huoNhLQvQVe+zPLXXAKdMPkTzsHWNkcoXe0MOnaY0gp+fYDh3nH8xbRlyzQnypWLKBj+8cS4pxOpJSM5jUGUkWS+TJguazW2pa94yUdKmoG8WyJ4UyJgmYlwnEIQW3IQ8jrZjRfYiSnTcjieTJueCM5y1JW0kyqg25CPhcjOY28LWrDPjfNMd+U9fWmwzQlec0gN85iWSgbE1xhHbY7YjTgJup3E/RMFJWGKdk/mGEoU2JBTZB51f7K/kxRswWkQcRvCciAx8VQusiuvjQb26tmHXefHOoh9cQdRDr/SGxwy1EBGWmFjTfDhjdCpInukTyHhrMsrA1NaMtUSCnpTRY4kshT0Ay7NIuT9pqj55qm5HDcKt0S8blZ1hBi90CazYdG2DAvxqrmKFGfA7oftQXkbyDTf/Qm4WZY/TK48B0Qmz+rZ51rekbzdhKjqeutHk80jjEm0A8MZSqW4Ok+j6FMkXRBmzHr8ulCiUabuRSN+wYyXPflBwDllqpQzBVjbqo/f/tFlUHiXKBEo0JxavrkoUyRwVRpUizi8fjR5k5esXEeTx4ZtQp0x3zUh30cHs7idjqYV33U5bWkG/x4SxcAfxfZCr96G8mFN+KsW0T40S/BRe+B6/9j2ns9uH8YU8qKQBp/7TEG00Ue2D/MC1Y28HRvaspYqu3dSdprgtPWlDtZiprBoeEsozkNhwOqAh4aIz5iAfcpGavohslIrsxQpkS6qIEEE4luSIq6QcBtJWhZcBLPJqUkkSvTlchR1I5aM91OQX+qyEiuDNKyjM6rDlAfPn6ynpkwTEmmqJEqaCTzGrmyPmF/wOMi6ncT8bkYyZXpSxVpjvpYVBea4Co6MUGNm/aaALv600T9bpY3Ti8mpiI+2EP+0R9St/+n+LNHrI3CaU1kbHozcuFVdCQKHBnJs7QhTPMsapoapuTISJ4jiRwl3cTtFFQFvSxvDFc8dVJ5jb0DaXRT0hTx0ZHIURP0kC7qNMd8LKgN4URCz+NHBWS652j7Vt4El7zXcvE+y+lK5BjJldkwv2rCdiktb4fZiMbxjIn5Te3VU07E9CWteqpjpXbOJGetaBRCXA98BXAC35VSfvaY/W8CvgD02pv+W0r5XXvfzcDH7O2fklL+4Hj3m0vRODZY/dYbN3LdqsY5aYNC8Vxna+cIr/jmZoA5TYqjRKNCcer65Mc7R1hcF6rUGZwN333wMH932QK2do2ypjnK5sMJnre0DiHgwQPxSVlZ794zyEMH4tyyJgE/eAmy7RK2L3o36+95AzSsgXc9NO299vSnSWRLLGsMs3cgM6W1cMvhBG6noGe0wIvXNk9Z922sLMD501g8ToTxQtHrdrCwNkjNKSzjcTyklKQKmhX/mCuTLWoMpEsYpkl10MuKprAlOk4whrNQNugayZHIlivJXFqr/BimpHskz0C6SNTvZllj+JTENB77TAXNIFWwRGW6YMVWxrNl+pIFYn43a1ujVAe9xALuSibY8a6fJd3AlJLLFtfh95xY+6RpkNhxF2Lb96juvgsh7ZInsTbY+Cbk+tezPxdgIF1kZVNk1klahjMl9g9m0A0TIQQuh2BxQ4j6sOWCqxsmB4ez7O5LA/DitU3Es2U64jncTgfLGsNE/W6QEnq2wmPfhl2/AtMW3G2XwsXvhaXXn9Wuq4eGs+RLxoQJqkLZYO9AepKYnA1l3WRr1wgxv4cVTRMnCo4k8jgc0Fp14vHaz5SzUjQKIZzAfuD5QA/wOPBaKeXucce8CdgkpXzvMedWA1uBTYAEtgEbpZSjM91zrkTj1+89yBf+sg+Y24GqQqGA5R//E0XN5B3PW8hHXrhiTtqgRKNCcer6ZMOUlfIbsxUZ33nwEG+7fBFHEnmEAK/bQe9ogQ3zq9jdl6Y25KHejksDywXtj0/386+XuPF840KoXkjxbQ/h+UI7DrMMHzwMwam9F0q6wdbOETtmzsX86sAkgfvQgWFG82Waov5p3eCs4+JcunjmxBzTUdQMDg5lSebnRijOhlxJt2oiDmToTxUrGVsbIj5aY1YSnFjAPatYQ9OU9KUK9IwWMExJ2OdiQW0Qw5TsG8hgmJJF9aFK/OHpZiBV4ImuJCaSurAXwzw6/hYIQl4XEslAqsjBoSzLGsNctqT2pMStkeontfl7BHb8GF/OsrtIhxux/AbM897MTu9asiWTDfOrZi1OsyWd3X1pSpqB2+mgbJjUR7wsqQ9X/u8eOjDMcLZEQ8TH8sYIAY+TvQMZMkWN5pifBTVBy+Ka6oFHvwXbvg8lS2xSsxguejesey14zrxYmg2WeJaVWMPBdJFMUX9GscY9o3kODmXZ2FZF2HZP3juQpiboPensq8+Es1U0XgzcIqW8zl7/CICU8jPjjnkTU4vG1wJXSinfYa9/C7hPSvnTme45F6KxrJss/ZiV/Gbbx649676gFYrnGumixtpb7gRg979fd0IZzU4VSjQqFKe2Tx5zlZut2/mYaCzpBjt6Umxqr2Z7d5KGiJXE5ZFDE+MHNx9KsLVzhCsX+Fnzw1VWAfaP9lG69cV4ux+CV/7ASvQxDQ8diONyClY1R3i6JzUheY9umPxgcycvXd/CvoEMl8yQ2OfgUMZyp40e38UQJgvFRXWhGetFno1kihpdiTy9owWyZR0BRPyuyne3QBD2WW6h0YCbsNc1paBMFTQ64jlyJb1SfzJb0olnS1QFPCxtCONxnX5LV6qgsasvhVMIVrdECXpdSGkl6hlze80UNfb0p+mI52mrDrC4IcT6eTFigRP87EwDbf/dFLd8l1DX3UdjH6sXoW34W56sfhHeSD2rW6KznnAp6yZ7B9Ik8xoRn4tsScfjcrK8KUzE5+bhg3GWNoQZTFvuwe12bGdvssDh4Rz1kXHxfMU0PPkj2PINSHVbN/BXw/lvhQveBqH6E3veM8DuvjQup2BpQ5iDQxkifnfF6nqyaIbJ1s5RIn4XK5siPHAgzhXTxD+fbs7WOo0tQPe49R7gwimOe7kQ4gosq+T7pZTd05zbMtVNhBBvB94OMH/+mQ+6fe13tgBww5omJRgVirOAiM/N6y6cz08ePcLVX7yfLR+dusaaQqE4d4gG3ET8bo4k8rMqweGwk3p4XU7KdhbNta1R7t8/TCxQQ9jnJpXXKjF2sYCb1io/24cM1nhCUM5CKY13yZXQ/RD5ffcSmEE01oW9uJ2CA0NZfG4HmaJWsSrcv3+YFY0Ra4wgMjO2u70myGOdI8cVjcOZEnsH0vjcThbVhVjdcmIxn2cTYZ+b1S1RVrdEkVKSzGscGclXMrbWBD1EA27KuklXPE+mpE04P+BxEfO7iQXcrLHFUVk36R7NM5or4xCCYtlgy+HEJNfL00HU7+aSRbUUygZP99jZU+fFCPvchH1uWm1Px4sX1ZIpajx8MI5DwO+e7qNQMqgKemiK+qgJeakNeakOeqYXfA4n7uXX4V5+HaR60bb+ALntB3hGDuH+679xvvPTlJa+mKebX07V8itprzu+xczjcrC2NVZJipMu6vjcDg4MZMhrBq1VAXb0JrlscR1up+BwPMf9+4dZ2RThiqV19CYL3Ld/mGUNYZpjEbj4PXDBO2DPb+CR/4a+J+CBz8PDX4F1r7ZcV+uWncJP4JmxsjnC1s4Rkvky6aJ+SlxI3U4HFy+qoTdZ4NdP9dJaFTgrc5/MpWicDb8DfiqlLAkh3gH8ALj6RC4gpfw28G2wZjVPfROnJ5Etsa3L8pj92ms3nMlbKxSKGfj0S1fzk0ePMJAu0pXI0VZz5oPNFQrFqWVFU4QHDwxTG/Yc14PA73aSLeuVbJVSSoQQXLSwhi2HE1y8sIZtR0YrCS5qQh4MKcmVdWS4EZE4CJkBaL/COr/zAYqaMW05nwW1QZ48MkrZMNk0v4rtvSkuWlhDZ9xKsPHitc2VY8faMhUupwOk5ZI7lVBI5svs6E1RFfBwyaLaE44JnCtMU5It21lLizqaYaKbEsM00Q2JISWCic8ihMCUkgNDVj28sm7gEILqoJfasAeXw2Flg82V6bZFZq5sMN7DTiIRQEk3yZcNvC7Bo4cTVIc8rGwKs35+9Wkrsu73OLlwYQ2pgsbmQwmaoj4W14cmfPZhn5sXrGzk8c4RLl5Yy6K6IIPpEoeGs3TGc/QlC/jcjso5XpeDWltMBo9NsBJtwX3NR+HKD8GBO9Ee+19ch/+Kb8+v2LDnV5S2LebgwtdQc9mbqao+fmIXh8MqYL+4PlRxqQ16nGiGQVmXfOv+Q7ztioUsqguxoCbI7v40+wYzrG2JceXSOvYOZDhk1yKM+t2w+uWw6v+z995hkqVneffvrZxzdc5pcp6dnbAzu5JW0iqgLBACZCGQABNshD8bh88GYWxsbAw2yJ8EKAESEoqruFrtanfSTs6xc06Vc673++NU13RPh+nZnbQz53ddfU3XqVOn3qrunjr3eZ7nvt8HI0fhlb+E6z+EM19SvrrfoojH9gMPROZjd62dsXCabKGE8Q5WpxtdZtwWA4VimUsTsWrkzoPC/RSNE8D8lO0mbhjeACClDM27+TfAf5/32KdueuxLd3yFr5G9f6IE/v7+29be90BeFRWVGwgh+IsPbeVf/OM5nvzTl9RZYxWVh4Rd7R5eGZgztVn+c9ds0BLPFKrxCbFMAZfFgEmvZW2dg2vTCUx6LaFkDq/NiMdiIJ4p0uSykDH6sdCvRAm07gODDWt8kGOXLvH41s1LPq9Bp6FQkrT7rEzEsgggnSsyGk7T6DJX58qsBh2pfGnFaItWn5XhUIrOeVWhRLbAxfEYFqOOPR3eW+bA3UuklOSKZeLZAomsIgwzecWkZS7OQiOUmT67SYfPZkCv06DTCLQagU6jQSNY1clzsVRmKpZlMpqhWJbotRpafVbqHKZlBXS5rLi4xjMFQsk8U7EMfbNJvn56gv/v5UHsJj3dNTYMeg0CgVGnwWJU2mE9FgNuix6zQcl0NBk0GLSa2zrRd5r1HOjxMxZO81JvgI0NzgWzbBqN4PEOL70zCU6NRNjZ6qbOaUJKyVQlR1BKaPFY8FkNhNJ5+maTpOc5u7rMBnx2Ax6LAZ1WB2vfjn7t2yEyAme+RPnMlzBG++k685/JX/gLRtZ9lNo3/y4mx+raveucJuqcJmIZpa3WZdHzRLePzx8ZZkuTk+5aOxsbnRRKZS6Mx8gVS2xtdtFVY+PCeJRiSbK1xaXMb7btU76C/XDsr+Dcl6Hvx8pX3WbY+9uw4b2gvbMuwreDw6QjninAKn8vV0u80oGwo9XNVEypyG5vcSui+gHgfs406lBaTt+EIgJPAh+WUl6et0+9lHKq8v17gX8jpdxdMcI5DWyv7HoGxQgnvNJz3suZxmvTcZ7580OAan6jovKgMudq/O3f3MfWZtc9e151plFF5e59Js/GswyH0uxqX95Q5idXZqhzmtjY6CScyjMTz7Ku/kaQ9vmxKD6bkd6ZBE+tUQTo3x4a5J1bGsh85Zdpm/oBvPczsOVD8I+/ANe+R/QNf8Jo58+zucm15HP2ziRwmHT0ziimFy9cm2Vbs4uxcLo6xzgWTgMsGcsxh5SSI/0hnuhWWhzPj0fRaQSbmpx33BH0dimXJeG08n7GMjfaRE16LQ6TrtKCqVuVkc2dIFcsMRnNMh3LIqVEr9NQ51AEzmoqiOWypG82waG+IHaTjha3BZ/diMWgJZYpEErliaUL5IolcqUy+WIZrRDYTXocZh0mnZb5BVKBQK8V6LSKKNZrNei0iiOpTqtBC/QHkmQLJba3eLCbdeg0ovpeBRI5Lk3G2NPhXVDVLpclY5E045EMGiHo8Fur8SJzLb3BZI5wKk9JSpBKFbPFY1FasEsFuP4DxZxm5AgAea2V4a5fpPlt/wqz6/ZmC7OFElen4lyZitPpt+IwGQgmc1XjnEKpzLkx5fd2c5OLfKnM+bEoTrOe9fWOhYWWVAhO/a3iupoKKNuczfAzfwFd92+85Gh/EAS3HbexEscGQ2xtdlV/tsVSmeNDYbrvcsv0fB7ImUYpZVEI8VvAcyiRG5+TUl4WQnwKOCWlfBb4HSHEu4AiEAY+WnlsWAjxRyhCE+BTtxKM95o5wfg3H1HPC1VUHlS+/PHH+fBfH+c9f3VEvbijovKQUOMwkS0oJ6FblrkY5LcbmU3kAHBb9Fybji+4f26+sbPGysWJGJubXOh1GqxGLdO6SvUlPqn8u+ZtcO17uMZeYKj9Q8zEs0s6crb7rJwcDuM06ymWJZPRDPs6PdhMN07F3FYDA7PJFUWjEAIhJEf6g8o8XJPrtuMZ7gRSSiLpAjPxLJF0XlkbAq/NQJPLwvr6pQ1p7iVGnZZ2n5X2St5drlhiOpblzEiEUllpA/bbjQuqvfPRaARr6hysqXMwHklzdSqOJiUIJCWyIrw2NDhxz8u0TOeLhFN5wqk8yVxxwVo8ldlbk15DSUKxJCmWyhTKyr+ZksRnN5LMFvnexUn0Gg2tXotS0aqoTw2Czx0ZosNnxWHWL2jbFQKK5TKHegPVWcNWrxW3xaBkcFoNKHpMkMoVOD4UIpUrIoTAa9tL0zvfhGP2BPbjf4Zh9BA91z9Dvu/vuNT6c+R3/SatzS0Y9Vo0QqkOi7l/uXFbCIFJr2Vbi5vNTS6+enIMv63EgTU+oulCJV5Gw/oGB1LCiSHlb2J3h5dQMsfLfQE6fNYbYyNWLzz5r2Hv78DFrylzj8Hr8Pfvg12fgKf/8L64rZr0GiLpwq13XCXZQgkpWXAxQKfVsLfTy0u9Abzdxvvebn5fcxrvNfeq0nh2NMJ7P30UUKuMKioPOnPVxr/5yE6eXl97T55TrTSqqNz9z+Tr0wmEgJ5a+6L7xsJpzoxGePdWxUPvaH9wkWtptqCYo5j02qr5hd9mInfic+y88Aew/j3ws1+EZAD+Rzdo9ch/PchLw5lFlaA5jg4E2dSo5EI6TXpm4ll2d3qrVYRbhYWXy5Lz41Fm4lk8VgO72lfXPngnkFIym8gxGk5TKCqZfW6rnlq7Cdc80fR6olSWBJM5JqIZspWWWadFT6PLjNO8+DVJKbk+k2A2nmNLkwuNBkbDaaIV8eCzGWnxWJYUoNlCqSomE9litTXXqNPgsSqGNg7TQqE9V1ns9NkWGDyVy5JTIxE8Vj1dNYt/v6WUFMuSZLZI70yCSLqASa+hzWvBatQjpaQsoSyl8lWW1TzJbLGEQNCVvUjn1f+LbfxlAAoaE5caPsi5ll/C6m6g1WtBpxVIyYJjAQuEbKFU4uqU8rfosRpodJnJFyUjoRSZQolahwmDVjASTtPmteKy6JmIZgkkshVhfJNjbLlE4+X/j6bzf4FGFkk7Oul/4s9IeTctfA9YGGmyHBKJVgh0WoFWM78t+kZ7tFYrFm2/MBYlVyzx1JraOzKCdnokQnetrTpnPZ9wSsm93NF6+3mQt8sDGblxP7hXonHuJPQrH9/Nns579x+6iorK7XN9OsFb//wgcO8u8qiiUeX1hhDiGeAvUDqD/kZK+Sc33f9J4FdROoMCwMeklCMrHfNefCafH4vithgWOapG03l+eGmKn9/VCijVjq3NrkWRC9OxLBORNIlcEb/NwEQ0yxZzgNovPQG2Wvi960p552/eDOMn4Gf/jkzXOzgxHF7SMj+YzDEdy3K4P8ivPtHO544M89E9rRjmCcyjA8ElRWMsXeDMaITNTU68NiOH+4I80X3nWuOWIlcsMRZOMxNXqrI1diPNHsuyhj+vd6SUxDIFJqIZYhUhaDJoaXSZ8duMVXEwN5tXKJWr7YRSSgLJHGPhDNlCCa1G0OgyU+80rThjmisqYjKUzBPPFkCCVqNUQOudZkx6DQOBJBPRLFubXFVHX4C+mQTRTIEdLe5bCpdkrkjfTIJUroTTrKe71rbsz7FQKjMVzTIZy2CZPUvLpb/CNa74dJS1RtKb/xm9nb9M2liD326k3WddMa5k7qLMSCjFUDDFtsqcnpSSkVCasUgal1lPOJVnc5MLt9VAqSy5OBEjnS+yrXmJPMnJc/DNTyhVR40Onvp92Pe7oL39JspyWVaMlyTFcrnyr7zxb2nx9hODIYQG1tU7q2J5Do0QWAxarEYdNqMOq1GHRa9d9mdUKkteGQit+Pd8ZjSizK3e5SSGB7I99WHl4nis+r0qGFVUHnzW1N24SnsvTsJUVF5vCCG0wF8Bb0aJuDophHhWSnll3m5nUXKV00KI30Axrvu5e7/ahWxpdnF8MIRJr6FmXsuozairmrEA1DqMzMSzi9pC65wmZuJZHCal+lEqS3ytG0jrPViSMxAeBG+n0qI6fgKu/xDz+nfRVWPj0kScTU0Loy58NiOnRyI0usxMxbI0e8z0ziZvGYlxbTpOLF1gf7evKkBsJh3xbGHJysRrIZLKMxxKkc4rIe4tHgudnbbXZSXxdhFC4LIYFuQhpvNFJqNZBgMppJTotMpc5KZGJ8VymTMjEaxGHRsbndTYTdWqcbFUZjKa5eRwhLKUmA1aWjwWvFbDgvfSqNNS7zQviFEplsoEkjmuTseVCqgAm1HLyeEQNqOe7a1uDDoN3bV2gpWWzuWq23PYjDq2tSiVqjmX3WyhRI3dRIffumDGU6/V0OK1KBdbOp4ms/0NjPQew3bsz/CO/wTb2c+y9cIXEds/QmjbP+fsaJ5CSS4vIIUiyFu9VhpcZs6ORtFpldbqNp+VNp+VQEKZuXz2/ATv3tqIy2Jga7OLTL7EubEoJr0S9VFt0WzYCr/2Mjz/n+DEZ+DF/wx9zyuzxp722/q5azQCQ1XQ3fqCyGw8y+5OH9F0nt1LZMOWy5J0oUQqVySZKzITz5LOl5YUl1aDjqlYhia3mUy+tGyr+dYmFy/3Bniyx3/fzDXVSuMdZq7K+Pe/8rh68qmi8jrh4niMn/nLw8C9qTaqlUaV1xNCiD3AH0gp31q5/W8BpJT/dZn9twF/KaXct9Jx71X3j5SSw/1KW+h8MfDXhwb41Sc6EEKQLZS4NBFjZ9ti8xwpJQf7goyH03T4rTS6LMivfYTWmefhXf8Htn8EZq/Bpx8Hixf+VR9otJweidDsNi8QqwBfPz3OjlYXk9GsMoNWkjzR5aueCJ4cDrOlSal65oolTgyFafVYF1VL0/kiV6fi7Ghd3vBntUTTeXpnkuSLZVwWPe0+6+LIBhVAqcJNx7JMx7MUKhmfpbIklM6zrs5Oz1xw/U2k84pbbjiZRzKX/WlZtTNmMldkOpZhNJSmdzaJ26Jne4ubepcZnUbwymCITY3O26pESSkJJHIMBFKUypJGt5kWj2Xl2bmpC+R/+t8w9H4PgLJGT2Ldh7C84V8RMdYxGEhRLElaPBaaPWaEEFydilPrMOGx3vj7CyVzXJiIsbbOvkAwT0UzfP30OHu7vGxrvlFBDacUodvoMtHpv+kiRv8L8J3fVByNDTZ45k9g2y/etXiOw31B9nR6OTUcZnur+1XHspTKklSuwAvXAmxqdBLPFsjkleiYJreZBpd5wc8imMwxFk5Xxf/dQK003iOuT98I5VUFo4rK64f51YCVzDNUVB5RGoGxebfHgcdX2P9XgB8udYcQ4hPAJwBaWlru1PpWRAjB3k4fB/sC7GrzVMWQUaclUyhhMegw6bXkKwJgqcfv7vDwjXCa8XAGKaGr6wmYeV7JlNv+ESV83N0OkSEYPwktu9ne4uKl3gBOi77qaloolal1GJmMZkEqKYFdNTb6A8nq7KXbYiCSzlMqS3pnEjze7l2y+mAx6Mjkl17zasgWSvTOJJS4EbOBzU3Oh7bt9E6i12po9lgWVKUT2QIz8RyXJ2O8eC3Auno7NXYTtQ5lVlEIgcWgY22d4tA752g6GkqTyBaQKNEbzW4LDvPSBkI2o46uGjtdNXbeuK6W0XCa0yNhxiJpTDoteo3gR5em6fBbebzduyrTFCEENQ4TNQ4lwmMimuH4oJJ21+qz0uA0LV5L/WYMH/4HmLlM8aU/RXv12zgv/x3lK19BdL2fTU//G8z+DsYiaY70h9BrBXUOE5PRzALR6LUZearHz5WpOEOBFNtb3Zj0WupdZn7tyU6+e2GCSLpAk9tMT40dj9XAkz1+RkNKNMljbZ4b0TRdb4LfOArf+1248m149reg90eKw6r1zp6Px7MFzAYtWo2odiI0uV+dEY9WI4ikC2xrViquc8xVqU8MhSlLid2ko9VrxWczMhJKEUnlcVsNKxz57vDgBPk8BMzNRamOqSoqrz++/KvKOfC7/+rIfV6JisrrFyHELwI7gT9d6n4p5WellDullDv9fv89W5dWI9jX6eP4UIhsQWlL9VoNTEYzN69vyccbdVq2t7oJpfNMxbJ41z+l3FGJJ0AIpUUVlOgClBPyx9s9HB8MV497bSrBxgYnOo3AbtYTzxRoqLSqzu1jM2g5PhginMrzZI9/RWdUh1m3INriVpTKkv7ZJIf7glyciNHqsbK/288mVTC+JuwmPV01Nt69tZFf3tembBQQSOZ4ZTDE0YEgrwyEqiIdFCfTTU1O9nb52NvppcltZiyS5pWBEEf7g1yaiBFJ5Zf9nWzxWHj3lkZq7CYksK3Fzfu2N5IrlPjS0WEO9QW4NBFb4OC6EkIImtwW9nb5eLzDS65Q4kh/iBND4aV/x2o3oPu5LyD++TES3e9FUMbf91XMn93NyLN/jF6U2dflZUuzi3i2wOH+IBfHY9W/v7nn3NDgZFuLm1PDEa5Nx5FSYtBpeMemBjQCLHoth/qD9M4kkFLS4rXwRJePk8M3rcvigQ9+Ad77WTA64Nr34NO7ofe5Vb3+1XJlMs6GBkX81zlNTMeyr+l4I6G04pA7D12lPXhPp5d9XT7afFZGQ2mO9AfJ5Ms8d3mafLG0zBHvHmql8Q4Rm2e7e68cGFVUVO4c850Tx8LpFS3vVVQeMSaA5nm3myrbFiCEeBr498CTUsrcPVrbqjHoNOzt9HF0IMi+Lh9ui4HpWLbqPukw64lniguMRubjtRnpqbVxcTzGWHMH9TobxugoxMbB2aSIxmOfhus/hDd/ClCqgR1+K5cn42xsdJLIFnBbnaytd/DitVmMOqWK0+qxMBpO47MZOTkSwW833nLOEaDDb6NvJnHLdrVAIkffbAIktPms7OvyPhIzivcDk17Lkz1+Lk/GSRdK7G73otEIxaE0pbQXxrPKOaO2EvlR5zQtmqWMZQrVmA9QZlib3JYF8R4ajWBjo5NsocTpkQh1ThNvWFtLMJnj4kQMn81A30xiwXxqrcN4y5+9ViPo8Nvo8NvIFkpcm05UL3B0+KwLZ+pq1mL/hS+Qm75G7Ed/TM3ws7Sf+1OyE89x+rH/irlpE+vqHSSyRZrcZi6Mx8gXyzRVWmE1GoHZoOWJbh9jYaWKuK3ZhctiYHeHl+ODYfZ3+5hJ5Hi5N0CT20yn38b+Lh+H+4NsqRjnAMrFmy0/B6174du/AcOH4Ms/Czt+Gd76x2CwLv2CV8nNsRhG3fIdCqshkMjhtRlu+fNwmPTVjqhSWXJpQss/nRqn2aMIy1fbHnu7qDONd4j3fvoIZ0ej/M6buvnkm3vuynOoqKjcXf7p1Bj/z9cvUOcwcezf3b3QYHWmUeX1hBBCB/QCb0IRiyeBD0spL8/bZxvwdeAZKWXfao57r2YabyadL3JsMITNqCOVK/HUGj9CCELJHIFkrtpCeDPRdJ7JShTAubEoHx3+NzjHX4T3/Q1s/qASkP6nnZCNwW+fUQxyKpweCdPssdA/m6w6o3724ACPt3to9lhxW/Q8f2UGvVbD9hY3g8HkqueWljPwklIyFEwxHsngqwjelVw8Ve48oWSOC+Mxtre6l5xdLJTKBBI5ZuJZMoUSSNDrNNTYjdTYTQuqzPFsgfFwhmglE9Nq1NHkNlfbX0FxUw2l8jzW5qFQKvPKYIiNDU78diP5YpnRcJrZeBaJklXachtOuFJKJmNZhgIpjHoNa+rsS5owzZz5Ps6f/B6m9BRo9KQe/5dcaPsYfaE8z2yqUyqjUjIeyTAaTqPVCLprbHgrs5jFUpnz41EAtre4SeaKXByPVS/sjoXTDASULNM2j4WjgyHW1TsWz3KWy3Dsr+CFT0EpD2374SPfAc2rr6ifGY3QVXMjFiOVUyJNXu2M4eG+ILs7PK/q7/LEUJgGl4mJSIbHlzDjebWsdH6i/u9xByiXJWdHowD87tPd93cxKioqr5oP7lSKKdPxLIXSq796qKLyMCGlLAK/BTwHXAW+JqW8LIT4lBDiXZXd/hSwAf8khDgnhHj2Pi33llgMOh5v99I/m0QgCaeUk3CP1VD9fil0Wg3FcpkDPX7CqTz5xspY51yLqlYP3W9Rvr++cKRze4ub08MR9NobFQWfzYjNqKdvJkGmUGI2nqPTb8Vu0pG7jeqFSa9Z0PKnxEFEOdQXRK/VsL/bx/oGhyoY7wNem5H93T6uTMbpm0ksul+v1dDgMrOtxc3eTh97u3xsbnKi1QiuTsc5OhDkaH+Qk8NhIqk87T6r0s7a5aPDb1XaXyvtrOfGorgsBnpqbBzsDVAolXmy20/fbIKpWAaDTkNXja3aDusy67k4EeNIf5DTIxFCydyyrbCgtJI2usw80e1jY4OTgdkkh/oCDAaSlMs3Hle7/R1ofvMY0z2/AOUC1lf+lD0vfIA3Oic4MRTmUF+AiajiFrqvy8e2FhfT8SyH+4JcGI9SLEt2tHpo9lg4NhjGZtRh0GlI55U222aPhSd7/Bi0Gg71B2l0mbk2FWcmflObqEYDe38bPvESWGuUquPBJbvmV0WpLEnnSguE8mQ0Q6PbvMKjlidRmY18tX+XjW4zpbLEpNcye/Nrv0uo/4PcAf7bc9cA2NuptnuoqLzeedvGOgD+4NnLt9hTReXRQUr5Ayllj5SyU0r5x5Vt/1FK+Wzl+6ellLVSyq2Vr3etfMT7i9Wo483ra7k8FWcwmAKUk2JWaL7SaQSFkkQIwfu3N/KDeAcAcuggzJ1s9zyj/FuZa5xDCEGbz8JYOFM9Ma+xG5mOZ0nlSrzSH+IDO5oYDqXRaAS30wTW5rMyFEyRyBY4Phji5HCYZreFAz1+mj0W9bzkPqPTatjTqRjTHO4L3rKd0ajT0uS2sP0WQvLadAKzXqsIzi4fXTU2wqk812YSaDWCb56Z4NJkjD0dXgYDKYLJGx3jcwY4j7V52NflY129nZl4jqMDyvzlcDBFcYULp2aD8rxPdPnQazUcHVB+7xKVtluD1UXdhz9N4APfJGNrgdnLNH79nWy7/ufsa7WRK5Y51KfMbWoqc41PdPto9Vi5OBHjcF+QQknS7DFzZjTCmjo71+aZTQohquJRqxEUS0rO4XgkvXixtRvgfZ8FBLz832D48O39ACv0ziToqbUt2BZI5vBZX11u4uV5s5Gvhkgqj8tiYFOjk8uT8QXC/W6hisY7wGdeHlT+/aUd93klKioqr5U/+9mtAPzD8dH7uxAVFZW7it9uoqfWzsmhMKXKCZdOq1n2pF6nEdX91tQ78PXsIql1IsIDMFO5yNT9ZtDoYfQVSAUXPD6VK7GlycXlyTiFUhmDTkupLJlJZKh3mTAZtHishgUn96uhVC7z8vUAvTNJtjS72Nvpuy/Oiior0+G3sbXFxZH+4G1Xhm4pJPuDXBiLEs8WaHSZeazNwwd2NDEaSvP5I8OUy5Lvnp8kkFj6d8ti0LG+wcG+Lh+7273otIITw2FeGQgRWaH6Pifenuj2saHBQV+l+jgcVDIt/RvfhP63XmFq/a+AlDRe/gyaz+ynM3OZAz1+6p0mjg2GGAgkAXBa9DzW5mFvp5dMvsRQMEUgnqN3JkEqV1xUCRVC0Oq18uQaP5ubnPzg4hTHBkKLF9r5Btj/eyDL8I1fXfS3eSuklMwmcovic5C8qszEm2cjXw2JbBGHSYdGI9jU5OTCROzWD3qNqKLxNXJp3g/JfocDdlVUVO49ZoMWQ6Vd5MVrM/d5NSoqKncTm1FPd42Nl3tnKZcl9RUL/aXQzhONRp0Wp81GuKXimHrpG8q/Jid0PKmcnN5UbcyXynTW2MgVSwzMJjHrNUTTeXpqbYQqJ+Zr6+xcm1rcxngzUkpGQikO9gYIJQtsanKyRXVAfeCxGXU8tcbPeDTD+bHoiu2gt2KBkOxaKCSvTMU5PxbFYzXQ4rUwHkuzq93D3x8b4ceXpzk1HFZmG5d4fo2m4qLa6WNHq5vxSIaDvQEGbmpDvRmLQcf2SvVRIwRH+kOcHgmTEybqf/bPmPngd4hY2iHUB597K/zw9/Eaiuzv9lMqSyVeonJ8jUaJotnf7WdPp4+hYIqzoxEuTS4tjIRQjHs+vr+DQDLHP54YXVx1fOrfQsseJcvxW7+uzDyuktFwmtabzPFyxRIG3e3LKCklxwZDbH2N0V4SWe0i8NmMFErlBaacdwNVNL5GPvzXxwD43EdVTwsVlYeFb/7zvQB87Av33qRDRUXl3lHnNOGxGfFYjRzuD+K3KS2jS3Fzm6ffbsS68+cAyJ//+o0W1XU/o/x79btLHmdbs5szoxEuTUR5y4Y6MnmJzagjni2g02qwGLWklolJKJUlV6fiHOoLIiXVecU2n5XR8BKteSoPHEIItre4qXWYeLk3sGAe9bUyJyR3tN4Qkvu7fexq83BsIESr10LfTIJUvsi16QQv9wY40h/k2nS8OjM4H4NOw6YmJ/u7fRh1Shvq6ZHIkvvOf30tXqX6uLbOwbXpOIf6AgwY1xP88I8ZXv/rSKGB4/8X/u9eGHyZnlo7nX4rL/cGFh3badHzgR3NPNHl56fXZjnYG+DyZGxJ3wEhBD+zpYF19crFl5euz96I1dHq4P1/A2Y39D8Pr/zlqt5TKSWDwdSiWIypaJY6p2mZRy3P2bEoa+scK0bpvBq2Nbs4VzEQuluoovE1UC5L4lnll/uNa9WYDRWVh4X5VvevxU5bRUXlwabRZaZQLJPOF9nQ4ODUSIT8Kk/iu2psXNVtIG2swZAYJTl4QrljzTsAAYMvKU6qKP+PzNniazQCoRFoNRqMOg1Os546p4nrlZmtDQ0OhkOpBc+VK5Y4OxrhlYEQHquBAz1+2nzWqpCtd7z2vDiVe0ud08TuDi+vDIaWbRu9Exh1Wjr9dj72RDvdNXZ2tHlI50o0uszYjDqQkqFAiu+cm+Q75yY40hdkIppZUFWcy3B8otvHmjo7VybjHO4LMhXLrFgttRp17Gj18ESXj0Aix0QKZh/7N5x+yzfIeddBZBi+9C747r/Eayyzt8vLyeEIU7HMomNtb3XjthhocpupsZs4uUL77JZmNw0uMzV2I7FMgSP9QUWcO5vg3Z9WdnrhD2H81heGL07EWFtnX3TRaDqepe7mdtVbMBpKY9BqXpXYnE+5LBEsXE8yV1R+nncRVTS+Bv7yp/0A7Ou6c1a3KioqDwbv2tIAwH/70bX7vBIVFZW7hUGnoSwlUipOl2vq7FyeilNeReuaViMwmwykupTKYv+LX1BOtG1+JSeulIe+5wEIJnPVSIBsoUS+UGJbi5srU3G6a22MhTPkCmXKZYlRp0UrBOl8kXyxzMnhMGdGonT4bTzR7aN2iRNVjUYg4TW1O6rce0x6LU/1+BkJpaoXDe4WQiizb+0+KxoB/YEkW5td7Ov287ZN9bxnayNbmlwIDRwbCPG3Rwb54tFhfnpthnDqhqi1GXXsbPOwp9NLMlvkcL9iaLOS47gQghq7iafW1LC+wQH1W/j2zn9gYOPvIDV6OP15+IcPYiylOdDtYzae48L44vbdZzbWcXI4TFlK9nb62N7qqrbP9s0kqu3jQNUxuFSWbG9xc3I4TP9sEta+HR7/DSgX4eu/DJnosusOJHIUSpJ652KH1HJZ3pbzaTxbYDScXlX+6q1IZIs4zAsF4oXxGFuaXvuxV0IVja+BP3u+F4D/8/Pb7/NKVFRU7jT/5X2bAPjbw0P3eSUqKip3E61GYDVoiaUL+O1GtjS5+MHF6QUnoMuxocHBVPPble8jL/C1kyPKHdUWVSV5JJDI4bcrovH8WJRWr5WuGhuZfIlkThGHLR5ztcW01WvhhxenOT4UYm2dnT2d3iVz/uZT5zQxpVYbX3cIIdjZ5kGvFbwyEFrV791rodZh4sk1NZTKZb57fqpaUTQbtLT5rOzt9PH+HU18fH8nH9jRhNdm5LnLM3z24AB/fXCAH1+eZiqWQQDdtXb2dyuGNnOVv7kcyflkCzfm/+ZE5wce72Byy+/wlS1foGipVSIxvvgziHSYLc0uvDYjh25ym7UadfTU2umbSRJK5jDqtNX2WatRV40AmRObPbV2jDoNk7EM+7sVp9WXewOkDvy/UL8VoqPw3d9hKbviQqnMpYkY25aYPSyWyrdlgFMslTk1HGZ3h2fVj1mJSDqP23LD7GosnKbBZbrrsTqqaHyVxDI3hk09qkuZispDx/w2jzF1VkhF5aGlwWXGpNfSH1AqPesaHLiteg71BRbFDsibMjlMei1J7xYSpgb06Rmakuc52h+Ete9Uduh7HvJpUnmldSyRLaDVCAw6TXW27eJ4jFqHIijHIulqbIJOI9jV7lm1yV6Lx6LONb6O6fDbWFtn52BvYNmZ1juFSa/lbRvr8Vj1/P3xkWUr61ajjs1NLn5+VwufONDJL+9rp8lj5nBfkL85PMQ/nhjl5esBQqk8GxqcbGtxMhpOc7A3wGgoXRVvE0vkGWo1gv3dft7zzDP8YNfnSVmaYPIs8vNvg/gkjS4zO1rdHOkPVltQc4UyJr2WvZ1eLk3Gq+fiQggaXGaeWlODEIownMtc7a61V+ca231Wdnd4uDCdpffJ/4002OHKd+DU5xa99hNDYXa2uZcUhzOJ3JIV/+U4MRRmR6vnjom68DzRWC5LBgJJOv22WzzqtaOKxlfJH35Xsdf+tQMd93klKioqd4tPvXsDAJ/82rn7uxAVFZW7Rr3TRDRTIJNX2kMdJj0CwfZW96JKx1KsbXAyUq+4qO7LvMyVqTgjJQ80bINCGgZerM4fXRiPsWleC5mmIgynYlmGgikuTsS4OhVnS5OLN6yr4fJkfNWvQ19pxVN5/eK2GtjX5eP0SOSGgctdQgjBk2tq2NLs4m8ODZEt3Fqo6rQa1tc7+eDOZj6+v503ravFpNfQN5PkhaszHO4PkswWMeo0jIRTPH9lhsFAktl4llr70iLLYtTxzgN76X3H10m7ehDB6+Q++2bys/1YjTqe7PFzfjxKKlckVyxj1GnQaAT7Or2cWcKUp91nZX+3n+FQimODIXLFEm6LoSoijTotezq92Op6uLLjD5UHHfqzBcfon01Q5zQte8FmKpqhfpVziVcm4zS6zbfsFLgdsoVS1Ujn8mSc9Q2Oe5LHqorGV8k3z0wA8Ltv7rnPK1FRUblb/NLuVgBODkfu80pUVFTuFjqthnJZ0uq1MDKvUucw6dnV7uFw/w2Hy5vNJ0DpNgq3K+2o4sq3+dD2Or5/cYps9zuUHSouquFUHptRh1G30DXRYtCChIO9Ad65uR6TXotGCBwmPZl8acWQ9ZuxGLQrOluqPPgYdBr2dyvGMRfHY3d9TnXuAsWXXhm5LSdXIQR+u5HHO7y8Y3M9T6+vxW8zIVFcfp1mPR6LngvjMb5zbpLvXZhkKppZ8vdZoxFs27CO6fd9g6RvK8bkOHzurVw8fYRsscTj7V4uTsTIFkrVWBmdVsPeLi/nxqKLjqfVKFX8TY1OTg5FKJYl16YWXoBpcJlZ88ZfoqzRQ3ycclbJioxnC8wmcitW7vLF8qribWbjWTKFEq1e6y33fTVkCyUS2QI1ywjyO40qGl8F4XlOTWomkorKw8v8K3eLMp9UVFQeGvQ6DX6bofp3bjYosRdWo469nT6ODgRJ54uL2lPnaF3/GCFzG6RD2CaP8syGOn5QfEy5s/eHiFKe4VCKnlr7gsdFUnle6g0os2RdPsbCmYroU55nbZ2dq6vIbZyj3mlW5xofAoQQbGl24bLoOdIfWtFk5k7QXaPMJn75+O0Jx/k4THq2NLvY1+Vje6sbg05DriRxWfQ82eNnTb2dl/sCfPPsBIf7AhwfDC3KiuxoaSH34W8Srt2LIRtk4/M/z/C5lzg7GiGZLRLL5DHOy0Y06rQIxLLdAFajrmIeZeTceJTR8EJXYp3egMbTDsCps6eZiWU5PRxhV9vys4flsmSJa0eLyORLXJmKs73Fdeudb4NsoYSmcm5ydjTK1jt8/JVQReOr4P/99iUAfudN3fd5JSoqKneb//COdQD8u29dus8rUVFRuVs0uc1MxLLVvMQGl7lq+2/Sa3miy8/xwTCZ/NIn1C1eK9d8b1VunPkCHX4b/tYNxB1dkI3hmDlONn+jpaxUlpwcDjMYTHGg20+L18Ib1tRwbjRKvcPETCUr0mszEknnVwxVn4/fbryr8Q0q95Zmj4UtzU4O9QXuenD7unoHO9s8fO3U6GvOjjTptaytc7CvSxFsNXYjoUSeZreFFo+FfLGMQachlMpzpD+0QEB6PV6KH/oKsda3IrIx1j//S+yS53GYdXz77ASRm4x21tbZb+k8W+8088EdTZwfi3K4L0hy/syopxOAnfYwL16boXQL5+TrMwk6fCvPD5bLkmNDIXZ3eO942+iJoTBbm12EU3lMeg0Ww92N2ZiPKhpfBd+/OAXAb72h6z6vREVF5W7zy/uUq5AHewP3eSUqKip3i1q7ItTW1Tu4NpXAZzMSSNw4OZ1rGeydSSzpDimEILfpFygLHVz7PkTH2NflY6L2aQA8oz+q7ts3k+DKVJyeWjs7Wt1oK0YbGo0SiTAaTlVFIygOkH2zyVW9Dq1GrFpgqrw+sJv0HOj2c2Eiymz87laRNze5WFfv5NnzE69ZOM4RSRfY1uJmb5ePvZ1e2rxWrEYdk9Esp4bD6LWCTY1OoplCVUCiNXFp319Q2vzzUEij+8rPsStzmBaPhWSuyMu9AQYqLqluq4FoJn/LNl6/3YTLYuCxdjfnRqNMzM2MehXRmJi4xqYmF4+1eTnUH1yyu6hUlgQSuVvmLJ4ejbCp0XnHuxF7ZxK0ei2k8yXOj0fZ3OS6o8e/FapovE1yxRt/RAad+vapqDzsaOc5p4WS6hV8FZWHEY1GUC6DUaeptgLefBKq02rY1Oji/Hhsyf8Ldm1ezyXnkyDLcOpzaDSCtv0fAsA18hy5fIGXewPki2V2ty8dobGmzo5OqyWcKlSrIXVOE9M3tfGthBCqcHzY0Gk1PNHlYyCQuusGOTtb3bjMBg71BRac874aZCUDdc6BVAhBndNUnYP8mS0NpAslvnh0mL6ZBI+1udnW4iaSLpApavii/1+R3vZxKBfgnz7KrtgPKZQkB7p9GLQaDvUpGZE1dhOTq2jL9tmMxDIF9nV5mYxmGA2lwasUgDLTvWxocOC06Hmqx088U+Rof3DBe3B1Ks7aevtyhwdgIJDEYdJXc1nvFIlsgWAyh0YIrk3HebISIXIvUVXPbTKX2fbOzfX3eSUqKir3il9/UrkS+T8r2awqKioPH7UOIzPxHB1+K4OBJBqNWGTaodHA/i4f16YTC6qBADaTnktNikjkzBehkMXcvJWisxVTPkxp+Ah7O720+63LTEZCjd2IViPw2gy8MhCsbm/3WhkOrW6u2mczEEypF7geNoQQ7O7wMDEndu7i8+xq92A16Dhyk2i6Xa5OJWjzLW8C47IYeMOaGn79qU7avFa+cGSYb5wep9Fl4un1tWxq9nBx4+8zsulfgCyz/tR/wDh7nlyxTLPHwoEeP7UOE1PRDEf6gre8sNJdY6N/JokQgsfaPARTOSa1DQDUFMarraRCCNY3ONjS7OL4YJjBQJJiqUwknV/RdCaazjMbz7GmbmVhebtIKTk1EsFu0hFJ59nb6butnMg7hSoab5P//qPrAPzbt6+7zytRUVG5V/zmGxTR+OXjo/d5JSoqKneLdp8iFuscJqZiWWodJmZumg8UCISAvZ1eBgMppm+qbtStP0DQvg7SIbj0DWaTOSYangGgcfJHlKVEI8SyJ7dCKMdfX+/g+kyCTMUJtdljXnUGY53TtGhdKg8Hc2InlMrRv8qW5VeDy2LAWJlLfLXCMZ0vEk3naXSZb7mvEIINjU5+7alO9nf7+Ifjozx7boIml5lMsUzL+/6QiTUfRcgybUf/LV9+ZaB6QcdvN/LU2hosBi0/vjJNcIWOIJ1WieuYez3bW9ycT/sA0IQHFu1vNeo40OOnWJZ8++wEGxqci/aZI18sc2Y0wq725U10Xi0Xx2PkCiUsBt09b0mdz30VjUKIZ4QQ14UQ/UKI31/i/k8KIa4IIS4IIV4QQrTOu68khDhX+Xr23q6cVf0RqKioPBysNlxbRUXl9YtOqwGhzC25LQZMOg3TscxN+wiKZVmt+gyHFrYLdtTYOeF/PwCpw59mIpym+YkPA9A++yLPX5oAKVmpe7TJZSGUzPPW9XU8e34KKZXna3CabsxhrYDdpCeZVWM3Hma2tbjJFkpcm159juftsrXZxfWZBLvbva9KOJ4ZibK91X3bz9vksfCJAx20+awc7AsyFcvw/QtTjG/7PXC14IheZffMV3llMMTF8Vg1m/QNa2twWwxMRDIcHQguO5M53zhnNpHF39BGWWdWLvRklo7XavdZAcFwKLXk/VJKjg2G2NXuveMto8FklhPDYba3uFeMAbkX3DfRKITQAn8FvA1YD/y8EGL9TbudBXZKKTcDXwf++7z7MlLKrZWvd92LNZ+vZMG4LeoJpIrKo0aLxwLA0XktYyoqKg8XnX4bg8EUPXU2RsJpcoWF7alGnYZcxd5fCMHj7R7GwumqaUa9y8Rg3TNkdE6soUtsE31oGraQsrZgyodwzZ7kxHB4xTa6RreZQDJHV40No07DxYkYAF01NgbuYnVJ5fXFxkYnAsGlyu/HnUarEfTU2hkOpdndoQjH5aItbmYklKLWYXzVRjBCCDY3uXjH5noaXBYO9gWIlQ1c3/kpANZc+0v2e5PUu0wc6Q9yeTKGWa8lX5RsanSyrdnNmZEIF8aji+Z7XRYD8UyRRLbA1akEO9o8aCpzjQPXLiy5nosTMd68vhaf1cipJf5+L07E6KyxYTPeWSfTVLbI3x8b5QM7mqhx3JssxpW4n5XGXUC/lHJQSpkH/hF49/wdpJQ/lVLO9WMcA5ru8RoX8D9+rLamqqg8qsxFb/zx96/e55WoqKjcLWrsRmbiWYw6LeWypFiWC04QTXrtggrG3PzXVCzLWDjF1akEQm9isPkDyg4nPgtCEGh9OwCPZw4yGs4wukzFApST9bmnbPEqbpHTsSxCCDxWw6oiNYx67bLxICoPD2vq7JgNWs6OLl0he600usxE0nkEgt0dXg73B24pHAulMsOhNF01r70qZjPqeLzdTU+tnaloltrt7yDc8W60pSzZb/0OXoueAz1+fDYjh/qDlGWZwWASs0HL3i4f9U4zL/cFGJvX2q3kHMKp4Qj7OiuRGN4OAKyp4UUiPFcskc2XcFr0tHgt1DlNnBi6IRznqv93ugMxnMrzlZOj/OzOZlwWwx099qvlforGRmBs3u3xyrbl+BXgh/Num4QQp4QQx4QQ71nuQUKIT1T2OxUIvDbL/EN9SoXhvdtWWqaKisrDyJvX1wJwefLutQOpqKjcX4QQWI06EtkC6xschNN5QqkbERvzK43zH7Omzs4PL00jpVQy1Nb/IlJo4Mq3ITFNrP2dAOivf483dnu4PBVfUfy5LHpmEznW1TnQaRS3xGyhtKpMOoD6iuOqysNPp9+G12pcIGTuJDta3ZweiWAx6FYlHM+MRNjW4rpj+YRXphJ8cGczbV4rJ4fDBJ/4A4pGF6axg1x//m+5MB7FZzPyZI+fDr+N5y5PV+M4/HYjT/X4yRVLvNyrZF0OB5VIm90dXqUlHSCviMo6i4Z4tlBteQW4NBFjU9ONWcYmt4UWr4Vjg2GS2QIDs0k2NS4/6/hqGAunOTYYZFuLi4YHaBzudWGEI4T4RWAn8KfzNrdKKXcCHwb+XAjRudRjpZSflVLulFLu9Pv9d2Q9eu3r4m1TUVG5g8z/ALwbH8wqKioPBmtq7fTOJHBZDNgMOoaDN6qCN1caQakInBmJ8LF97ZQl5EuSuKmOSPOboVyEU59HW7+JlL0d0kHqo6fp8tt44drMsnNXdQ4Tw8EUZoPScvd4u4djgyG0GoHVqL1l0HuN3XjXM/1UHhxavBaaPWZeGQzd8c8nk16L325kLJyuCsflWlVnE1nMBi2OO+QDUCyVSedKOM16Hu/w4LIYiODk9JrfA2Dt+f9KkyHNwd4AkVSeJreFJ7r8ZAuKSBypVPS7auzs6/TSN5vg746NsK/Lh9lQaZ1NTMPAC6DRw5q30+q1Vh+XLZTIF+UiX4N6p5lmj5kvvjLM4+2eOyaQQYn1CCSymPRatrfc/kzo3eR+qp8JoHne7abKtgUIIZ4G/j3wLill9bKclHKi8u8g8BKw7W4udq5c7bM9GCViFRWVe8+6egcAh/vVuUYVlYcVq1FHOl9CSsm2FhfXpm5U9ky6haJxJp7lymScA91+dFoNO1rdGHUapmNZSo99Qtnp1OfwmiWjdW8BQFz5Fm0+G3UOE89fmVk0c5UrlrAYtRRKyvYGl4lQKs+6egfnxqJsaHByeWrlOTadVrOgWqLy8FPvNNNVY+NIf+iO53T21NoYqMROWAw6drV7ODEUXrBPuSy5PBln4woOo7fL+fEY6yq5iCa9lkKpjMOsp+UNv0q0djekQ7iP/CEHevz0B5JcmojhtuhxmvU8WXE9nRPSc1XFLc0uemeSXJmMKwL7wleVbNU1z4DVS4NTcU8GuDAeY3PT4tdTKJXpm0ny9k31nByO3JH3W0rJqeEwBp2GQkmyo/XOitE7wf0UjSeBbiFEuxDCAHwIWOCCKoTYBnwGRTDOztvuFkIYK9/7gH3Albu52L/6aT8Av/3G7rv5NCoqKg8wv/6kMvfw2YOD93klKioqd5O59k6vzUgyX6RQqaoY9TfaU8fCaYaCKfZ1eRdkpu3t9CGAo8W1ZDzrITWLb+BbTDe9TdnhyrNQLrK/24+UcpG5ViqnWOvbTDqSuSKtXiujoTS1DhM6jYZAModeqyGdv4VDqlC7Ih41auwm1tbbOTIQvKPCUQjBtmY35yqGkFajjhqHccGs4MWJGBsbnHcsP3AklMKo0+C1GRdsj2UK1DjNuH7200itEXH+H8n3vsBjbR7cVgMnhsOkcyWEEHT6bXTX2DnUF+TSRAyNEGxscPJEtw+3Vc9L12Ypnf0H5cBbf6H6WjVCEM/kkVJivcncplAqc7gvyGPtHtp9NtbV2znc/9re72yhxMG+IM0eCya9FptJh9P84Jlu3jfRKKUsAr8FPAdcBb4mpbwshPiUEGLODfVPARvwTzdFa6wDTgkhzgM/Bf5ESnlXReMPL00D8HOPNd9iTxUVlYeVd2yqB27MN6uoqDyctPtsDAWUFrXtLS6ODip/80adhlyhzEAgSSCZW7Y1bW2dg1imQGzbbwCgP/aXGOrWk3Z0QiaMc/oVtBrB0+trGY9muDqvcpjKFbEZdTQ4TUzHMlUL/1JZsrHRwcBskg6flUsTK89Xuy0GIrdoY1V5+PDZjKyvd9xx4ei06BFCEK7M+HbX3Kg+xjIFcsUyfrvxFkdZHeFUnoloho1LzAqWpVT+JrydiKf+DQDy+79HLKVkQu5sc3NhPFptMfXbjXitBk4OhymWy7R4FSf0eqeZ/dZRtMHrSIsfup6uPkebz8KPr8wuykScLxjnnFK9NiObGp0c7Au8qur+WDjN8aEwj7d7cFn09M0kWF/panrQuK/DeVLKH0gpe6SUnVLKP65s+49Symcr3z8tpay9OVpDSnlUSrlJSrml8u/f3qs1v1r7YBUVldc/OnWeWUXlkUCrESCUk8TNTS76Z5KUK/mMY5E0mXyJ7S3uZdvHHGY9zW4rk83PkLE2QXgA7+RPCLcpLqreke8DYDHoeKqnhrOj0eoMYipfxGLQ4rMZma2Y5TR7LIyF00rMR4eHCxMxSuXyitl5imjML3u/ysOLtyIcX2sF7Ga2Nrs4PxatZodubXZxdjTC2VHF/OZOkC2UOD8WZXe7d/GdEsrzRyn3/g5YvFgSw1y7fpFQModZr2Nbq5tMocSxwRBTsQyJXJGf3dnMiaEw2nl/s7oLXwFgrPmdpEs3tlsNWmKZ/I25R5YWjHO4rQa2Nbs52BegWFpdLEmpLDk+GCKRLXKg24eUcKQ/yOPt3geuLXUO9QxoFdxuoKmKisrDy1znzWxCNZlQUXmY6apUUkx6LTUOE72zCYLJHOl8cckKyHwaXWY0GoHTaiGy5ePKtkufwb79gwB4Rn8MJaUKWOc0saXZxU+vz5LJl0jlSliNOqXNT9443py1v1GnZX29g5Jc2c3ZZdETVSuNjyxem5GNjc47Khy1GkFPnZ3eGSUv1GUxMB7N4LUa7ohJZLkseWUgxJ5O75Jtrv2BJN2186I8tHpoegyAx7QDXJ1KEE4qbaVr6xw0u83806lxOv1WjDoNmxpdHBsMkcgWoJCFS18HoO7JX+HYYKg6r3xpMk5XjY1CRQCuJBjncFr07Gh1c/ymWc+lCCVzHOwNsKbOzvoGB6l8iVcGg+zt9C0Qqg8aqmhcBc9fmQFgf7fvPq9ERUXlfvOzO5UW9WfPTd7nlaioqNxNauymaiyGz2ZkNJzmwliUnhr7LR/rsujRahSjnIanPkHe6MYeOo+xECHl7EKfj8Lgy9X9NzQ4qbGbePHaDNl8CaNOOT3TaATFUhmNRpmzmqti1DpM2Iw6JiKZZSsbJr1Wvej9iOOxGu64cGx0mat/F9lCCY/FQDCVvyPzs8eHwmxpdi3Z1TcRzaDTaPDfNONI404ANJOn2dflZTScYiqaJVcscX0mwa8d6GA0nOGn12Zp81rY3+3j9EiE5IVnIRuD+q0YGjaxt9PH0YEgs5WcVp/NSDJbrArGXSsIxjkcJj06jaiKzZuRUnJxPMZQMMWTPX5cFgOxTIGTQ2H2d/sf+G5GVTSugn88ocRJfuixlvu8EhUVlfvN+7Y3AfDNM4vMnlVUVB4y7CY9sUyBeqeJiUgGr82wqtaxOTMNKQGDBcMeZbYx9eL/oLDmPcpOV7614DFPdPsolCRXp+PV56h1mKotqu0+K8OhG/EfW5qcFMtlrkyp2bEqyzMnHA/dQeFoNWqJZ/KcGAqzq91Ll99WrT6+Wi5Pxqh3mvBYF6cUZPIl+meTrK+3k735QkiTIhoZP4UQgl3tHqZiWb59ZoI9HT6Mei07Wt3kS2VGw2l0Wg0Huv3kT/+98riKAY5Jr2V3u5cvHx9lbZ2NWKaAxaCtCsabDXGWo8ljYTySWbQ9lSvycm8An93AzjYPGo0yH3puLMqBHv/rIs7vwV/hA8Ccvf5cuLeKisqjy2NtSm6SeqKmovLws67ezuWJGOl8EbfFQDRTpNozegtMBi0GnVAyFXd9nLLOjHfqEGlHOwDy6neheGPmUK/V8GSPn1AyR/+sEvNR7zQxFVNOQGsdRqZj1eQxhBC8dUOdGgGkcks8VgOb76Bw7Km188NL03TW2DAbtDR7LAQSuWVzR2/FeCRNsSRp81kX3Sel5NhQiN0dnmoczgIatwMCpi9AMYcQgnyxTIP7Rkt3uSxxmPX47EamY1k0ySncU4coa/Sw6QPVQ12ZivOBnU0cHwqTyZU4MnB7ghGg3nHjb3aOwUCSs6NR9nR6qXeaAZitxPXs7/JVza4edFTReBsYdOrbpaLyqPOgDqirqKjceYw6LVqNYCycwW830u61VjPcbkWjy4xWaBiLpMHiQbPjowCYBn9M2NaNyMZg8KUFj3FbDbT7rVwcjxFK5pQW04LS6iaEQK8VC1pOLQYd3TV2jg2GllyDXqtZMoRd5dHDPU84vtYMz0AiR6FUpsFpqm7b3urizGjkto8VyxQYDqaXzEMEODMaZUODA6NOi9mgJXOzaDQ5wdcDpTxy6gLnx6I0us3s7/aTLZS4OhXj6ECIDQ1O1tTauT6TgAtfRcgykaY3gcUDKMLVpNfS5LawscHJDy9Psb3FfVuCEZSW8rlO3UKpzNHK+/1Etw+jTmk/nYhm6A8kF8X1POioKkhFRUXlVaKGZ6uoPPw4zHpypRI6jaDWYWQmnqVcvrUQ89uMZAslYpmKGc2e36QsdLiHvkfSuxkAefmbix7X7LZSYzdxbCBUFYhz82KdNTYGA6kF+z/Z4+fqVJxIarFTqsusJ5pRHVRVFOaE42uZcQyn8kzFsuxs8xBI3qh8Www6HCY906u8qAKKYDwzGmFP59KOoeORNEadhhq7Ik6zhfLSVbmKGc7IhYM0uM24Ky2uGxocXByPU5ZlPFYDGo2g0QqFk18EYLbz/ZXjlhgIpNjQ4CBfLPNy7ywf2tnC2dHoqt1Q5+M0K9EZh/uDbGpy0l17Yw56JJRiMpphT8eD65K6HKpovAVzv/x20+1daVBRUXl42dCgZCidG7v9q6oqKiqvLyKpPE0uC3aTjqlYlnaflcuraE+fX0GQUoKrmUzPexCyhLsYAKB45XtQvHHiXSgpJ8WPdygzT0f6gjjMeuKZIqAY8oSSC0WgQaehq8bG6ZHIohNcl8WgOqiqLMBtNbCpIhxv17wmWyhxfjzK4+0eOv02BmYXXsDY0ODg6lR8VYI0lMwp83zd/iWFYDpfZLAi5OaYjGaon1fdnEM27gCgNnGJZreFcuV1nRmNsK/bR6PbwqUJJQu188x/QR8bQno6iTQcoFwuV3MSCyXJ4f4ADS4zG5uc7Ghzc3rk9j7ny2VJNKPMKj7V48du0lfv659NEkkXeKxt6XzXBx1VNN6CF64pzqlvXqfOM6qoqCg82eMH4OVedZZIReVhRkqJBDY1OZlN5JiKZWnzWRkNpVdVgdBpNZXMN0W4mZ76XQDM0ycoWGrQFxIMHX+2un86V8Jq1KLTatjb6SNXLDMdyzI5b0bKZtLdqF5WWFNnx2XWc+qmE1w1dkNlKTxWA+vqHRwdCK1aOJbLklcGQ+zpUFoq9VoNZSkXCEQhBBsbnVysCLTlmI1nuTqVWHaer1yWipDruCGugskcHutiIyopJedlFwDmmTNohKBclpwfi+K1Gml0men028gVS8RPfRVx+nNIjYGpN38au9nMqZEIXTU2NEJwuD/A7g4vAoFJr8Vh0lMsy1V3FcWzBV7uC9BTa6fBZV6w1qtTcbKFElubXas61oOIKhpvwU8qcRtPqyY4KioqFQ5URWPgPq9ERUXlbhJM5vHZjOi1GtwWA7F0HqdZT6PLfMsTY1CMbAw6TdVNUVu/kVDT0+hKWfTpWWWnS9/i+rRifBPPFnBUKhNOi57uWjvFsuTcWLR6zLV1dq7dVOmssZvIFEt4rAaGgjeqP3qthuIqWmlVHj38diNdNTaODYZXJRyPD4XZ0rQwDqPFY2E0nF503GyhpGQhLsF4JM1gMLXsPJ+UkhPDYTY2OKszgAC90wnW1i2MuymXJYf7gzT2bFM2RIbJZDNMRDNYDNoFxjrbrBEsP1Iu2vDMf6FX0wGyzGw8h89mqApGi2FhZ2Gr18JIaGFFdSl6ZxJcnlCMbWrspgURORfHY2gqgvr1jCoab8FPrysnhWpGo4qKyhzbWxQH1fPzTuRUVFQePorlMjqtcmK7ocHBeDSjZCgKQaZQuqVbZK3DRCJbXFAZjDz2uwv2aQ2+xPhsiOvTCWYTWfz2Gzl0XTU2nGY9w8FU9STcpNdSKstFlU63xYDPZmQymiGZK76m163yaFDrMNHitSyqUN/McnEYTW7zkvESW5pdXKtcCJnPUDDFTDzH4+1Lt2dKKTk2GKbFY1nwd5AtlNBpNejmxVKUypJD/UE2NDjxF5UCD45GXuqP0OQ2L5gjpJBF8/WPoiumCLW8DfHYr9JWed0+m4Ej/cGqYBwLp/HNe+5Gl5nJ6PJzmqlckUN9AQxaDXs6vdU1NrmVx50ZjWA1allTd+t81wcdVTSukvk9ySoqKo82qpOyisqjQY3dVA0y12mV2cH+mSTpfJGtza4FFcClMOg01da2uWpO3drdxJqfru6jKaSoCxwlWyhyeTK+KOB7LlT8+GC42grYVWujb3ZhLl5PrZ3emQSPtXk4ObS66pGKSqPLTK3dtKzz6UQ0Q2GZOIylHH2BBa6/c/TOJEhkC+xodS8pGMtlyZH+EJ1+Kw0u84L7Lk/GWVd/Q3QVS2UO9QXY0uRUhOz0BQDSnnVE00V2tHoWHvzH/0HZx91G5On/yVAozVQsh8dq5NRImD0dPiwGHZl8iaFgiu4a24LXaNBpFl0gklJycTzGhfEYu9o9i96fOoeRn1ydxm8z0uG38TCgnvmoqKioqKioqCyBViMWzGzt6/RxpmKAZTHo0GsrOYwrIcBpujFbaDPqGNr4Wwt2WRN8nlReqVwOBhaKQa1GsLXFRbpQ4nTlxH6+mJ1jTqDqNIINjQ7OjEYBJTbk1ebnqTwatHgtuC2GRd0z8WyBoUCKLcvEYYBSDe+/6QIGKA6ic38blyZilMqSzU2uJY9RqrSZrqu3U+NYaHRTLkvS+WK1eFMolTnUH2RbixuXpVL5nL4IwKSpm31dN3UGXv42nPxr0Brgg1+gq6WRU8Nh9BrBUCjJjlYPZoO2mge5a4kqaE+tjb6ZG69xNpHlpd4AtQ4jezq9C9poQRGUL1ydpcNvo9ljWfa9e72hikYVFRUVFRWVFRFCPCOEuC6E6BdC/P4S9xuFEF+t3H9cCNF2H5Z5VxBCVKuFep0Gh0lfjbfY3OTiwkR0xcfX2I2YDZoFbXz5mi2k2m5UG7X9z2ETBZrcFuLZ4qIZqma30q4XSuaq9/ntRmbjC9vmGl1KoHmN3YRWI5hNZHFb9ETSauyGysq0+6xYDNqqy2i+WOb0cITdHSs7fXptRiKpxRdOOvxW+gNJzo5GMOm1rKt3LPFopWp4sC/AliYXXptx0f0DgSSdlUpdvljmcF+Qna1unOYbHYC5ifPKsfwbaJ9f8QsPwrO/rXz/lv8MDdtI5oq4zHoODwSxGXRVIXt+PMa6OseiSj9UXIgzeXLFEscGQ8zEcjzZ7V8kcOHGnKWExQL2dY4qGldAbe1QUVG5FeoVfJWHHSGEFvgr4G3AeuDnhRDrb9rtV4CIlLIL+F/Af7u3q7x7tHotXJ1nPLO23sFAIImUEr1Wg8dqYCa+/MxTg8tMPFskPs8YpNljJrD9X1Zvi0KKhuAhEtkCGxocBJM5xuYZjLitBuxGHW6LgSuTcZK5It1LVHjmG5NsbnRyeSKO1ahd5LaqorIU3bV2dFrB1akYrwwqVbf5c4TLYTYsbt+0GLScHY3gtSqGO0uRL5Y5NCcCLUuPgU3FstQ7TeSKJQ73B9jV7lkwMhZJ5RFTlfZU78YbbqzFHPzTRyEXh3U/A7s+gZSSo31BysB7tjYyHs1iNeqq8Xp1S8R5gKIH4pkiL16dZVOjk01NziVNfOYE8JpaOy6LAf0q3rvXEw/Xq7nDzF0VrFviSoKKisqjzZyL2/yWFRWVh5RdQL+UclBKmQf+EXj3Tfu8G/hi5fuvA28Sr8cgsiVocJkpS1kVce1eKxpB1aV0XZ2DK1PxZS80z81Kwby5RoeJcfM6wo1vqO4nLn+TJ9fUcGYkwvYWN1OxLFOVqA2HSUc8W2BnmwetRnB8MIRGCLQaseBkXaMRVddGjUawrcXF9ekk2YLqoKqyOtbWOTg3FsNj1WM1ri6j3GM1Lqhml8uSowMhWrwWPDbDko/JFhQR+HiHZ1nfkNm4YgyVK5Y50h9kT4dvwZoCiRxX+/sxZAOUDHaa2tfcePCP/1+YOg+uVnjXX4IQHB8Kk8wXOdDtx2XWY9RpGI+kuTYdX7YFN5Yu8HJvgO5aG16bcdn3JJrOc6gvyI5WNzPx3CKn14eBZUWjEMIhhPivQoi/E0J8+Kb7Pn33l3b/uTCulOg3r9DLraKi8miyvhI4fGXq1rb7Kip3k3vwed0IjM27PV7ZtuQ+UsoiEAO8S6z1E0KIU0KIU4HA6yeyZlOjk7Fwmkgqj8uix283Vc8RNBpBu9e6IOpiKVxmPZHKjJcQApNew/DG367e7x35IXXGImaDltlEjsfa3AwH08zGs9X2QK1GsKNVcW8+Mxphbb1jkUtlu+/GWlwWAw6TnsnoYodLFZWl6JtJsKPFRSiZX3Unjct8Y2Y3Wyjxcm+A9fUOHm/3MrDEvGM6X+ToQJC9nb5FERfzuTadoNltqe5rNiito1IqOYyj4TS7zZMAJJ1r8TsqBjpXnoUTnwGNHj74eTC76JtJcHkixts31WM2aDkzFuFtG+v41tkJHm/3LmrBLZUlp0ci9M0meKLLh8usx25aeq29MwmuTSc40OPHZtQRzeRxW5cWy69nVqo0fh4QwDeADwkhviGEmGs23n3XV/YAMNf20VP78F0tUFFReW1saFAuJl2ZjN9iTxWVu87r5vNaSvlZKeVOKeVOv99/v5ezaoQQ7O7wcm4sSq5YxmHSY9YrVQpQWlhHw+llQ8CdFj12s666P8C6egcztvWkW99Y3RY7/yybGp1cmYpTlrC7w0PfbJJg8obpjddmxGszki2UiWcKJLKFBVXOWoeRmfiN/bc0OxkOpSiU1GqjysrMxrPEMgV66hTBd2KVLrwOs554pkA0neeVgRB7Or24rQacZj2J7ML4l2SuyPHBMPu6fEvOD85xZTKOz2bgxHBowb6pXLFiQmNiR6sbzYzSmprzb1CEX3gIvlMxmnrLH0HjDkbDKZ67PM1H9rRWjzMaSlOSkvX1jkVZpuORNAf7AnT4rOxsU1p0+2aTi/RAoVTmaH8QnUb5/0GrEUzGstQ7F7q/PiysJBo7pZS/L6X8tpTyXcAZ4EUhxKIrhw8rY5X/3Js9D+cPX0VF5dWzpvLhcX1mcRaViso95m5/Xk8AzfNuN1W2LbmPEEIHOIHQHXr+BwKNRrCn08vRgSDNHgtlKembVWYbhRBsbnJxfjy65GMbXWYS2eKCE2irUYfFoKV/3W/e2PH4ZwFlHvHCeBQhBHs6vFydipPOFavZjFuanOSLJQYCSbxWA2PhG5VEIQRG/Y0ZMyEEa2rtnL5FFp/Ko004lef6TKJayTYbtLT7rFyduvVnnFYjmI5luTIZ50CPf4EYNM37XRyPpDkzEuGJbt8ix9H5TEYzBJI5ZhI5nujyV/cdCqY4NxZlX6fvxvxhJW7D2b5dmWP8+scgF4O174THf52+mQTPX5nhl/e1oa8cp1AqE80UAMH2Fnf17yeTL3G4L0gyV+SpHn+1WpjOFzHoNDfmJSvv1+G+IBubnAsiNYYCKTqWiCd5GFhJNBqFENX7pZR/DPw1cJAlWk4eRuauCDa7Hx67XBUVlTtDk1u5mLRS6K+Kyj3ibn9enwS6hRDtQggD8CHg2Zv2eRb4Z5XvPwC8KB9CNzmTXsuOVg8T0TQj4Qw9tfZqe6jHaqBYkgsMb+aYix+4ecizs8ZGr24N+ZrNyn6hs1wdGsVrM1KoHEujEezr9DETz1VNboQQ7Gj1oNcKZuJZRsILW2M7fFYGAze2WQw67KaFlU4VlTkiqTyXJmLs6/QtaNNs9lhI5opVt+DluDwZI54tsKfTu0BYAXT4bfTNJjg1HCaaLrC/27eiQUw8W+DEUBitgCe7/Rh0GqWiNxCkWCqzr8t3Iys5Ooq89gMAjI1b4Csfgskz4GxBvusvOTMWZTCY4ul1tViNN+Ymr08nyBZKbGt24bLoiaRyXJqIcXY0ws42N2vrHAvehyuTcdbPc3+9Nh2nfzbJgR4/jnnzmKlcEbNBs6RJzsPASqLxu8Ab52+QUn4B+D3gkfBunjPCaVJFo4qKyk3UOJTuv5VcE1VU7hF39fO6MqP4W8BzwFXga1LKy0KITwkh3lXZ7W8BrxCiH/gksCiW42HBadbzhjW1DAdTaIUgmMyRLyoVwK3NLs5V8hHnM3cCqtdpqvtCpQKZK3J55x9XtznO/jXJXJFtLTeOpdEI3riuhlcGQiQqotRp0eM0G3BbDExGs6TzN6qYHqthgTGJRGnD659NLnh+FZVoOs+FiRhPdPmWFDs7Wt2cG4tWq9zzKZclxwZDWAw6OmtsS0Zz6LSCl68HafdZ2djoXDG+o1Aq893zkzS4TOyrrCeQyHG4P8jGRifdN4+LvfBHiFKOVMsb4Uf/FgZeBKuf0oe+wpGJEla9DqdZT6v3RuUvni3w/NUZ9leOH0rlOTeuGP/sXaJltlSWZAtlrEYdhZJiyGPSadnV7lkkkK9OxVlbt3S0yMPAsqJRSvmvpZQ/WWL7j6SU3Xd3WQ8GVffUZSx4VVRUHl3mhvdz6gmYyn3mXnxeSyl/IKXskVJ2ViqZSCn/o5Ty2cr3WSnlB6WUXVLKXVLKwTvxvA8qBp2GNbU2hkMpzDot5yqh6AadhgaXmeElTHGMei1Wg45Q6sa8odLW6uRgvK66reni/+HUcBidRtDoNldNbXw2Ix1+GyeHw9V2vw0NDiKZAj67npPDkQXHFSyMDhNCsLPNw6mR8J18K1Rex8QyBc6NRZcVjKC0nm5vcXPqpvbmXLHEwb4AXTU22n1WjDoNueJC45z+2SSXJmJsb3Et65A6h5SSLx8fZU2tnV3tSoPE+bEoY5E0T3YvrOgBMHEGLn4NAEvwPIweBUcjuV/6HgdjNfTU2ZiIpXmszVN9SCSV55tnJujyWWn32zg+GGI8kuFAz/KGPP2zSbpqbISSOQ73Bdnc5KRtifbTeLZAvlhetePs6xE1cmMVVMvgKioqKioqKipAs9eK2aDFZzdyZSpGqGJW0+m3MhxKLarMNLhMFMtlgomFxd9NjS4CyRy5j71Y3bYufYbeGSXUfDScplAqo9dqkEj2dPh4ZTBEuazMUu5sdWPS6bg4vrAa5LMbCSRyC57LZtThtRoZDaltqo868WyBM6MR9nf7F1XMbsZp0eO2GKoXQ2KZAkf6g+xq9+CzKV03cy3YcMMgBmBvp49Wn5WJFRx8pZT8/bFRNjQ42NnmWWB2s73FvVjQSgk//g/VmyIdAncb8Z9/lqNRD7vbPVyejLOnw1d9bbOJLC9cnaXObsRs0NI3m2R9g4OtzS5aPNYFc8HzmYlniaTzDAZTPNnjX1L8RlJ5zoxE2NXuWeIIDw+qGlJRUVFRUVFRuU02Nzq5NhWnzWflnZvr+Yfjo8SzBYQQbGt2V6uPc9TYTaRyRRK5hTOPEkmTy8y5Ylt1W+13fo5gMkc6X2Rrk4sL8wx2zAYtmxudnBhWKoZ2kx6vzUC718oL12ar+7V4LNUZyPn01NoYCqUWVYVUHh0S2QKnRyLs7/LdUjDOsabOzlgkzXAwxYXxKAe6/Quqc06zgVimUK3IbWxy0lVjq9ynuKsuRaks+dqpMTr9ilPpkmY3N3P9BzBy5MZt3xqm3v9tLqZcHOjxc248xpYmVzWiYzKaUar3OhgJp+nw2xYIQMXldfH6xsJpJiIZrAYdj7V5lqzGziayXJqMcaDbj26FWc2HgYf71amoqKioqKio3AX8diOxjBJ34bOZeMuGWn56bZbzY9Fqnlt03lyhViNYyhpoJpZjb5ePvpkk5bfcmG18TF7i1HAEp0VPvigXzCx6bUbqHCYuTypZkWtq7ZiNWmZimWpFx6TXVtvntUJU40CEEDzW5ub0sOqm+iiSzBU5NRzhiS7fbYscu1HHob7Ako91mHScGY0wVKnIzW8ntRq0pPLFmw9HrljiuxcmqbGZeKzds7TZzc2UCvDVX7xxu24zfe/4KtNlF3s7FafhRpcZT8X5dDSU5tp0nJFQmulolo/ubVvgdjqf+e3cM/Es3zg9zts319PiXdrbZDKaoX82uWJ778PELX9bhBBaIcS7hBC/I4T45NzXnXhyIcQzQojrQoh+IcSioXkhhFEI8dXK/ceFEG3z7vu3le3XhRBvvRPrUVFRUVFReb1yNz+vVRYjhMBu0hGqOEuuqbXjNOupcRh5uS9Ao8vMubHoornCcvmmk9NElrV1DhwWHdfr31Pdbnj2N2hymRgIJNnW4uL8WGzB87f5rBRLkrFwupojmS2UuToVq1YRdRpBvljGpNcuCGq3GHQ4zHrVyOsRI5UrcnIozBO3cDC9GSklp4bD2Ex61tY7SOYWCsBsocSxoTBmvZadS1TkljK/SeaK/PTqLBa9lg2NjuXNbm7mh/8apHIxRNZv4+wb/g5h9bOtxV2trM+JvP7ZJKdGwpwfi1LnNPHRfe0Yl8mG9NgMhFJ5pJScG43wnXMT/LO9bTjNS89ijobSTEQz7Onwrmju8zCxmt+Y7wIfRbHtts/7ek0IIbTAXwFvA9YDPy+EWH/Tbr8CRKSUXcD/Av5b5bHrUSy/NwDPAJ+uHE9FRUVFReVR5a58XqssT5ffzpXJOKCcGG9qdDIbz/Fkt5/ZRI5YusD16Rs5dzUOI4VSecFJd6FYxqDTsK3ZzflAGdn5JuWOxCQdgReYrFQOjXoNqZuC0jc3ORkNp4mlC1gMOra2uMgVy5wcUqqIDS4z07EsRr1mkWnX+noHV6biqwpvV3n9k8mXOD4UYl/X7QnGQqnMwb4gLR4LXTU2Njc5uTCuXMCQUtI/m+TEUJhdbR58duOqjhlO5TkxGKKMVKJgopmlzW5uZvAlOPW56s0jT3yBhvq6qlHNZDTLxkYnAKdHIjx/ZZp0vsT2FhcHuv2LnFGXeq3PX5nh+kyCX9rdVs1pvJn+2SShVI7H2jyPjGAEWI3FT5OUcvNdeO5dQP+cw5oQ4h+BdwNX5u3zbuAPKt9/HfhLofx03g38o5QyBwxVLL53Aa/chXWqqKioqKi8Hrhbn9cqy9BVY+MHF6eqt702I70zSbLFEluaXbT7rXzp6DA6jaCr1k6908TAbJJgMo/dpF8g2Jo9FjRCEOj6ADUDLygbX/gUOz9+lNMjER5v9/D5I8NVUxygWmF8uXeWvZ0+drV7+fRL/TzVY6V/NkmDy8T16QRui2FBpRGUGI81lZzJdfUPb0yAilIJfGUwuHLb5xIkc0VODIXY1e7FVnEFNeq02E06BgNJRsNp2rxWDvT4V33xYTKa4fpUgsFgihavhY2Nzls6qwIw8gp86d3Vmy9/4CLbOutxmPRk8iUuTMR4sttPuSz58olRSuUy6xscmHRa/HYjXtvKgnYklCKdK2E2aHnf9qZlhfW16TjFkmRbi3tVr/dhYjW/OT8UQrzlLjx3IzA27/Z4ZduS+1RyomIoV1BX81gAhBCfEEKcEkKcCgQCd2jpKioqKioqDxx36/NaZRlcFj2ZQmlB9uG2FhdnK/mKDpOej+xp5cJEjEN9yjmIUachWHFajaQLC6oZB3p8PF/ahtRWTnDDA5gv/T01diMT0Qx1DhMjwYXmNlqNUBxVBxRH1Z2tHkbDGaZiGTRCkCmUlqw0glKJDCXzqinOQ0y2UOLoQJC9nT6MutU35c0msopZTre/KhgBiqUymUKJF6/N8kSXrxo/EUkXcFuWrswBaITg6lScn1yd5vJUjDevr+Ut6+tWJxgHXoTPP1O9efyNX2H32kYcJj3FUplXBoPs7fQyHc/yFy/00VNrZ2uzG7tRj06rWXaGEZRq6aWJGBfG49Q6TLxlfd2ygvHSRAyBqFYzHzVWIxqPAd8SQmSEEHEhREIIEb/bC7tTSCk/K6XcKaXc6ff77/dyVFRUVFRU7hav68/r1yNCCPx2I2PhG7mMJr0Wp1nPbGVe0GE20Oaz0lVj49xYlIlohlxBaTOdjGaon+cQWec0Y7bYibW97caTvPzf6XIJhkNpOmusXJyMLlqH2aBlc5OT40NhNjU6SeeL1DvNnK5k65l02kWVxjm2trg4N7r4mCqvf+YLxlu1Zs5nIJBkJJTmwE2zj8PBFIf7g6ytdfBkj5+p2I2Z2OlYljrH0m6nxVKZQ30BfnBxEq/VyCcOdNLqXZx1uCTXvg9/997qzf62D/HYE2/DqNMipeTYYJj1DU5ODIX50aVpPrCjCY/VQLGstIFvb3Ete+hcscShviDhVB6bUceeTu+yhjZnRiNYDFrW1D26Hf+rEY1/BuwBLFJKh5TSLqW8E30ME0DzvNtNlW1L7iOE0AFOILTKx6qoqKioqDxK3K3Pa5UV6PLb6JtNLti2vt7B5XnzgluaXFybTrCnw0udw8yJ4SjhVJ54prDIaOOpNTWccbzhxobkDOL4/2Vnq5uhYAq3xcDYElEaXpuReqeJwWASv00Rsl6rgUA8h1Z7wz31ZmxGHQadhnAqv+T9Kq9PcsXbF4xSSs6ORiiUygvm9eLZAi/3BiiWJU/2+HFa9HTV2OgPJKu/49FMHpdl4e9yuSy5OB7jrw8N4jTp2dTk4u2b6lffInvx6/CPH67eHKl5I10f+XRV2J2prPXcaIRktsh7tjWi1QhCyRzxTJE9ncub1MzGsxzpD2LQCeqcJrY0O5fcV0rJiaEwfptxxYrlo8BqfmpjwCV55yelTwLdQoh2IYQBxdjm2Zv2eRb4Z5XvPwC8WFnHs8CHKu6q7UA3cOIOr09FRUVFReX1xN36vFZZgVafldl4bsE2jUbQXWOjd0YRk1qNoNNno382yeZmJ40uEwOzCa7PJBaJOY/VgKbraQr6eXr/yP/GWorjt5uQZbngZH0+bT4rmXwJu1mP06ynJCWBZI54psBKfh2bK1mQ6q/Ow0G+WOZIf5A9HasXjKWy5Eh/iBqHibV1juq2M6MRrk0pFzy6amxVYSWEoNVjqUa8IG+4pEopuT6d4PmrM1ybjtPpt7G700uLx7J645iTfwvf+JXqzaB3J+6PfAk0yus5PhjkymQCnVbgNBt48/paouk8fTMJUrkiO9vcS7aZzr2m0Ugas15Lo8tCp9+GZol1TUYzvNQboM1rodmzdOzGo8RqROMg8FIl4uKOWXhXZhR/C3gOuAp8TUp5WQjxKSHEuyq7/S3grRjdfBL4/cpjLwNfQzHN+RHwm1JKtSFfRUVFReVR5q58XqusjM2oQ6MRCzIZAZrcFgKJXLUttMVrYSqWxW7UIYA6l4k2r5VD/UHGIwsrhzs6axmvf/rGhlwcDv1PtjQ56Q8kaXabGQymWIptLW6CyRzpfIlwKs9jrW6O9AURLH+yrtUI2rzWZY+p8vqhUFIE4+4ObzXc/lZk8iUO9gbY1OSk0WUGlGD7g30B2rxWdrV7lqwONrrNTMWylMoSjUYgpWQgkORgX1D5vZfgNOt5vMPL2joHiezirMbFLyALz/4OfP/Gf11Z7zomn/lbHDY72UKJ71+YZCCQot1npcltYU+nl+szCXpnEuh1Gg70+JeclZyNZznYG6DBaSKVK9Fda6fZYyGZLVazVQFimQKH+gLEMgWe6vFTs0zb7aPGatxThypfhsrXHUNK+QPgBzdt+4/zvs8CH1zmsX8M/PFS96moqKioqDyC3LXPa5WVaXSZuD6T4PF274LtO1rdnB6JsK/LBygmOefGojjNeq5PJVhb76DRZebadIIj/UF2tLox6bXYTXpGe94Do9+8cbATn8X4+K/TVWNnKpalWJZ0+KyLKjdajWBzk5MfXZrmZzbXc24sSrEsb9l+2uaz8nJvgFaP5bZD31UeDPLFMof7A+xq92IxrOYUX4m/OD8eZW+XF6NOSzJX5OxohBq7iad6/CtWBo06LYVimUAiS65Q4uXeAJ1+GzV2I6PhFBajjt0d3mrFr1BabMa0gMgwfO0jMHW+uqnsbOH0E3/N7o4Wrk7FGQunyeRL1DlMbG1xYTVoOTEUYiycYXPT0jmPhVKZ0yPKTGJXjZWr0wl2trqrwjJWaRPPFUucH4uhESxYt4rCLX+jpJR/eC8W8iAjpXykclhUVFRUVF5/qJ/X94/HO7x8+djoItFoNmjx2YyMhdM0eyzYTXoMOg1arYahQIon19QghGBdvYNMvsSp4Qh1ThNdNTY6dr6N3GEfxmwQvF0Q6oeX/iumTX9Eg8vESChN32ySniVOkmvsJmodJgaDKSUiwaxjKJRkT6cX7TJGHwBbm1ycH4+yo9Vzx98jlbtLrliqVhhXKxjnAuqf7PaTK5Y5NhhCqxHsaves2mk1kMxxbTrOrnYv6+rsHB8KE8sUaHJb2NjoWP35c9/z8I1fhWy0uklavPS/5Uu43a0c7A/S5rEyFkmzqdHJY20epISfXJkhmi3w5nW1uJZwbx0LpxkIJOmqsTEYSGHSaxeJ4XA6R75YZjiYZkvzKiNAHkGWldBCiD+v/PtdIcSzN3/dsxXeR7wVG+xAIneLPVVUVB41ysuYSqio3GvUz+v7j8Wgw2zUMh3LLLqvp9bGYDBVrbJsbnIRSeWJpPMLKhlmg5Ynun0IAUf6g2h1OmLt7wQg6+4BjQ7OfwVztJdWrxWjTkPvdGLZOcQ3ra3hlYEw21pcDMymWFfn4Px4dMXX4bToyRXLCyJEVB58soVSdYZxtYLx0kSMeLbA9lYXp0cjnB+PsrlJEWOrEYxTsQwv9wYwG7TUOU10+m28eH2WaLrA5mYXm5oWG8ss2SJdLsFP/wv8wwcXCka9leT7v8KhiJN8qcxjrW6+d3GSp3pq2NXupVSWfPXUKCUpee/WxkWCce49iWcKWA1apmJZ9nR66am1L1jXSCjFy70BWjwWnuj2qYJxBVb6zfq7yr//414s5EGkxWshlMozEk6r/cwqKioLmK1cTPLdIjBYReUe8Mh/Xj8IvG1DHd+9MMU/29u2YLsQgu0tLk6PRNjdoVT6tja7ePH67JKdTJ1+G7UOE0cGgmzc+H64+gWYPENuyy9hPPt5Ws7+D9jxDXa2efjmmXGuTyttrjej02roqbVxYTyGxaClVJaUpeKE6VjhxHhDvZMrU3G2NrvuwLuicrfJ5EuVnMLVmd6Uy5LjQ2H8dgPxbJHTwxE2Na2uulYuS0bCacbCaWocRvZ3+Ujmi/zDsRFevDaDXqvhwJqFuY4rkg4r1cWBF5BCQ1HvRJ+PIjU6xt/8Gb4z4uFDjzWSKZT4yokx3rutkSa3hVSuyJdeGWZ3h5dtLe5Fh+2fTTAZzeCyGAil8mxpdi1yKY6m81wYjxHLFPjwrhb8dvU8/1YsW2mUUp6u/PsyiuHMFSnly3Nf92qB95O2SobMSGixtbWKisqjTX/FYr+rZpVZUyoqdwn18/rBwGMzIqVcZIgDYDfpsRl1TFdy7Yw6LRqUQPSlsBl1PNXjZ9K+iYylEVN6mj7LNqTeimf8JzB6DK1G8JYNdfy0Ij6X4rE2D6PhNE6TjoFAkq3NTs7eIpPRadGTyBbUborXAel8kVcGg+zrWp1gTOWKvHh9llK5zHQsR6fPxt6uW1fX0vkip0ciHBkIotMI9nf7WFvnQKMRjIXS9M0kcVn0vGld7eoF48Rp+MwBGHiBstnLbPPb0OejAFzd9Sec0m/j5x5rZiiU4vx4lDeu9dPktjAZTfPXhwZ477bGRYIxmSvycm+AeKZISYLbYuBAj3+BYMwWShwbDDEYTLGlyYnPZlQF4ypZccJTCPEHQoggcB3oFUIEhBD/caXHPEy0VOx1R0Oqm5iKispC+mYTAHTXPLpBvyoPDo/65/WDwpYmF8cGQ0vet6HBwdXpOKWyZDKWYX+Xn+cuTy97LCEEW1rcyI3vA6Ahcorhno8qd/7kD0BKnGY9GxudvHR9dsljuK0GahxGRsIZmt0WRsMZmtxmhm7hkjqXwafy4JLMFTk+GOaJLv+q2knHQmm+eWYcDbCu3sET3T6cluXFopSSiWiGw31BrkzGWVNnZ3+3n+ZKbIaSXxji5esB1tbZ2dflX3FetnphQ0o49Tn43DMQGyPt20Ssdje1o98HYGLXfyC55n1saHBwaSKOWa+hyW2hs8bOmZEw3z47ya8d6KTOaV5w7EsTMU4Oh0CCTit4srLWOeYyI8+MRNjU6GR7i5uLE3G2tbhu+d6pKKw00/hJYB/wmJTSI6V0A48D+4QQv3uvFng/afMpv2xDaqVRRUXlJubCvLtrH+2wX5X7j/p5/eCwtt5BLFNY0gtBCMHWJhfnxiKUypJ1DQ4iqXy1+rgclm0/C4C577tEN/8KGb0LRl+B3ucA2N/t5+pUglhmaXdUh0lPrcNIJJ1nPJKmzWtlJJSiuIKTZb1TiVJQcxsfTBLZAieHwjzR7VsyCmM+5XKZZ89P8ML1Wd68vpY3rqvFu8JYRa5Y4uJ4jMP9QTL5Ens7vexs8yyoIGYLJb57YZLJaJZmr5mNjc5brrlYlhhkFr79G/C934VSnpnWd6I12XEPf5+y0JF7258R3vwJMvkSoWSBTU0OYpkiGxscfP/CJP2zSX79yU7M8+Y2o+k8L16bZTaRxajTsqvdw+YmFxrNwrnFg30Bap1G9nb5sBp1TMUyuK36VedYqqxcafwl4OellENzG6SUg8AvAh+52wt7EJirIFybit/nlaioqDxo9M/MtaeqolHlvvPIf14/KJgNWuodZq4sc97gthrIF8vkS2XavFacZn21+rgsdZvA2425ECE1cpYTTb8MgHzhDxUTEeCZDXV8/8LUki2lPbV2CmVJrlim2W3h4kSMbc1uzo1FV3wtjS7zjeB2lQeGeLbAqZEI+7t9K0ZCSCm5Mhnj0y8N0Oy28NG9bQuqczcTTOY42h/k7GiUJreZ/d1+umpsC8QXKOaQf/fKCD6rkT2dXprcllsKV4BioJ/1P3g/nP8KZZ2J0Q3/HE/0Esbxo5TNXjQf/S7XGt/PxckoTR4L21pcXByPs6HBwddOjWE1avngzubqesplyZnRCEf6gwBsanSxt9NXzaaUUjIWTvNyb4BiWfJkj5+aShuqlJJr0wnWLzELrLI8KzUe66WUwZs3SikDQohHwlpoTZ0iGucqCioqKipzXJtWTgqXsrtXUbnHPPKf1w8SPruReLbAZDRDg2vxSbrLYuD6dAKbUUs6X2Rzo5ML49ElDT0AEAI2vAcO/ikbIy/ykzWfJD3zVSyzVyif/yqabR+m3W/l8lSc0yNhHrsp9sNq1CGkpMFlYiKaQacVGPUahFCqNEvFFAB0+Kwc7g/S5LYseb/KvSeWLnB2LML+Lt+yWZqlsuTadJzBQIpcscyvPNFRFVI3UyyV6Q8kmY3n8NoMPNbuWVGIHhsMcXY0wgd3NOOzGzk6EKTeYbp1rue1H2D61q8hcnGyjjaCXT9Lw4W/QldMIes2IX7uH3h+ysR0LKoIQyE41BfAZtTxrbMT7Gx1s6nJVT3cbDzLyaEwEuVcvavGVjWUKpbKXJ9JEErmafZYONDtW2Q2dXkyzvr624gDUQFWrjSulAK7ckLsQ4Ia6qmiorIc8WwRUN1TVR4IHvnP6weJzhorArg+nViyghhJ5dnb6eXSZBytRuAw6ymWJbFlTHEA2PBeAFwjPyKcKaF9478HIPPcpyjm0pWsRzvJXJGx8OKRmnqXmZl4Dr/dSL3TxLmxKFuaXJwfjy37lBqNwGXRE06pv0IPApFUnnPjUfZ3+5cUaYVSmXNjUV4ZCBFN52lwmXj/9sYlBWMsU+D4YIjjQ+GqWcyGBuey5725QokvHB0imMzx60924rMbqxEy4XQev32Zz8FSEX7yh/CPP4/IxRmteQMzjW+l8cyfoiumYP17CHzwO3x7WEuxVOaX9rSh12r4zvkJAoksU9Es79vWVBWMhVKZH16c4rnL09Q6Tbx1Yx3dlQiNVK7IyeEwx4fC1DpMHOjx0+6zLhKG2UKJWKZArZqKcNusVGncIoRYqr9CAOo7raKioqKi8mCgfl4/QBh1WgolydZmJ68MhNjX5a2euEopkUCNw8RwKI3ZoGUymmFbs4vD/UGevCl0vErNevB2Q6iPxzVXOW57mgM167HOXuHY1/8H237239PptzEeyTAUTOG1GRbk9XXV2PjBxSneu62Rl3sDGHUaylJpQR0JpWj1Lu0Cva7ewcmhMHu7fHfjrVJZJaFkjsuTcfZ3+Ra1i2YLJS5NxMgXy/TU2bg+naTJbVn0M50fl+Ew69nS7FrVPF//bIIfXJzmZzY30O6/ccy+mSTdNXb6ZhJLHycZgG98DIYOIoWWM20fx5cbpvXqZwAoPvXvOdn0McoRiddqZH+3j1g6z98dG1HW1+Rkc5MLIQSFUplDvQGuTMXZ2+XjLRvqqqY7s4ksfTNJjDoNGxoct8ypPDMaUc1vXiUrRW5opZSOJb7sUkq13UVFRUVFReUBQP28fvCodRjJlyRdNTZOjUSq2yPpAu5KO+j2FhfFkuTaVBydVkOn30bvzDLjMEJUq4114z+i1W9nbMf/A8BjY5/jCy9eIJMvUWM30eGzcnI4ssDExqTXUiwpt9u8Vkw6Lb0zCTr9VgaDqWVnKvVaDVqNIFcsveb3ROXVEUjkuDqV4ImbBGMyV+TYYIhzY1HW1jvY0ODkwniMTU3OBYJxqbiMrasQjNlCie9fmOKVwRAf39++QDAChFK55SuMQweVOI2hg+SMPo5t/iPWxA7ROvkjpMHGxFv/lmONH6Ozxka+VGZ3u4czIxG+eHSYOqeJd21pYEuzm3imyMHeAJ8/MoTZoOU339DF9hY3AhgIJDnYGyCYyLO7QzHruZVgvDgeo8ZuuuV+Kkuj9l+uksIKLmMqKiqPFqqjoIqKykq0+awMBVPUOU14rQYuTShtoKPhNC1eZUZQp9Wwv8vH6YqobPZYCCRyZAvLCLQN7wHAM/ocrS4jE74DFJt2o81G+IXyd/jMwQF8NgNDoRSdfusCM55iWeKx6pmJ52j1WohlC4SSisPrpkZndX1L0eG3MRhQo8fuB7PxLL0zCfZ1eauCMZrOc7Q/yLWpOFubXezu8DIbz3J5KsaTPTU4THoKpTL9s4ll4zJuRf9sgm+dncBl1vGLj7cucCsFxTTHYzUwm8jimJeBSC4B3/skfPFnIDHJlGMLQ7v+E7v7/xxb+DJ5Rysn3/RVymvezs42N5cmYzS6zBwZCHF6NML6Rifv3dpIJF3gYG+AQ/0BCqUyv7S7jT2dPvKVFtwjA0GMOg37u32sb3CsGPUxx4XxKGaDVjWvew2oovEWbG5SbIRPDUdusaeKisqjQn/FHKvVqxpEqKioLEav1VAqS6SUdPhtCKFURlK54oLogja/jVSuSDqvzEjvbHNXReQiataDrwd9LgzDh3is3cu5tUqiiu3MZ/j4NitfPjFKIlvEbtSTzBarc5LZQolGt4WhYKoy/+ggnS8xHc/isxlJ5Ytk8kuLVZ/NQCipzjXea6ZjWfoDSfZ2KsZGk9EMh/oCDIfS7GzzsLPNg0Gr4cRQmEJJ8libh6FgksN9QU4NR7AZ9ezrWhyXsRLJXJGfXpvl4nicXe0e9nUv3S7dN5Okw2fl8oTibgrA4Evw6b1w6m8pCx1nOn4d9+5fYO2RTyJSs0x5dnHxmW+y47F91DlN/PjyNKWyJJkrMhhIsq3Zhcdq4OhgiFyhRFlKNjQ4edO6WvKlMq8MhDgzEqXda2V/t58m9+oEMMC5sShWo04VjK8RVTTegrduqANYMYBXRUXl0eJgn2JUubdTnfNRUVFZmnqniclKBuOGBiehZI5wanF+Y7PHwonBMKC0kfrtRkZCS1T2hID17wFAXv4WWo2ga/sbCTe/GQppbMf+jN98qovhYIpvnxtnR6ubM6MRymVJtlDCbtKTL5aQUlLrMGExaOmdTgCwvcXN2dGlxaoQAr1WbVG9l0xGMwyHUuxq83BtOsGhviCpXJF9nUprqUGnIZUr8uK1GTRCaWE9NRzBatSxr8vLnk4vdU7TqkWVlJJLEzFODYcplso8tcZPp39pgVUolZFILk7ElVbRXAK++y/hS++G2CiztrUMPf3XbNcOYfrxv4ZygfGef8blN36eHeu7yBdLfO7wEG6LHqfZwIXxKFaTFomg02/FbTEQSRfY3eHBoNNwqC/AUDDF9lYXezq9OC2313F/ZjSC06xf9vWorB5VNN6Ct26oBeDHqmhUUVGp8KNLUwC8pfL/g4qKisrNtHqtC8Rfm9dKKlcicpMbaaffRqFUYjCgdDB019gYDqWXFmmVuUaufhdKRVwWA9E9v48UGjjzRfSxIX7jqU7GIxmeuzzNpiYnZ8ei5Iplah1GzAZdNXtxS7OLsUiGbKGESa/FZtIxm8gu+Vra/VaGg4tdWVXuPCOhFIOBJFoBxwbDeK2Ku2l3rR2NRlCsVN2+dHQYo05Lo9tcFYr1TvNtx0hE03leuh6gXJYIIXhyTQ1u69IxLKDEVbgseiwGLc7Jg/DpPXD685SFjrNdv4Vr38foPPgvoO85ino7M2/6c5o+/L8xG41cmYzxhaMj7Gp3MxhMc2E8is9q5APbm2nzWTgzGsVp1uOy6DkxFCGTL1WFslF3a9Oemzk9orx/7b6ljZ5Ubg9VNN6Crholg23uaqGKiorKyUq7+hOqo6CKisoyaDUCKRXXSoCZeI5nNtZxfjzK9Lxzio2NTqKZIuORDLliCSEEO1uXaVOtWUfG2YnIhGH4IAAd63cy0/F+KBfhxT9CCMFvPtXFSCjN0f4gWo0gli7gsxkx67WMhhTx57IYqHUYuViZZ9zY4OTyZHzJmW2/zUggsbhKqnJnOT4U4qXrAYx6LesbnDzR7aPGYVLyFGeV1tOvnx4nlSvwa092sL/H/6qEIii/l2dGI/TPJvHaDJSk5EC3D4NueWkQSeXJFkoEg0E2nPoP8Pfvg/g4Qcd6ht74f9laPI/huX8NuTiR5qcp//Pj1O7/ZYaDKa5OJ7g4EaMsJefHYmxqdLC91c3T62s5MRxmKJDCZtAxGk5XhXJXjW2RW+xqkFJycjhMjd20rDOwyu2jikYVFRWVV4ma5aqiorISzW4L4xGlspfIFnBZDDzZ4yeYzHG0P0i2UKLOaSKSzrNjnlC0GnW4LQbGIzdV94Qg1vFO5fvL36pu9rz9P1LSGpVtE2dwWQ1sbHRi0msYCaUYCqaw6LUkc8rs5Jxb6oYGJ4OBJFJKNBpBT62da5WW1YVPK9BpBfmiagp4pymXJf2zCf7ulREC8Ry/8HgLj7V5MOo0DAQUoXhyOIJJr0Grgd0dXp5eX4dG8+o/f0ZCKV7uC9DoNJErlnGa9Wxrca8oPqWUnBuLYh97iSd+/E7E2S9R0ui5su5fYN76ATpf/h3E8CHyRjeJd34W98e+Tslax+G+AAd7ZxkPp5mIZHj31gbetqmeXLGMVgiePTdBOldCr9OwvsHBvi5FKL9aFMEYod5potmj+g7cSdQznttAdUxUUVFRUVFRWS1NbjNjNwk/IQQbG51sbXFxeiTCtekE2oooc5r1TFbaR9fW2emfTS5yb4/Picar34WSYnRj8LaQ3fZxZftP/hNISbvPSmeNHZNeQyxT4PRoFImk2WNhLKysqc5hQqfRMBZWnrPRZSaUzC/ZGtvusy49a6nyqoilC5wcDnN0IMRwKM3uDg/PbKxjJJzmSL8iFM16Lfu6vGxtdtE3k2RtnYO219BqGUjkeOn6LMWyZFuTi8tT8UURHctxaWCUzaf/HRt++jE0iUlins307ftfrI0fxXrwU1DMEOt6D/rfPgkb38dzV2b4yolR0vkiZ8ej7O708C+e7sGs1/Lc5WnOjkYYj6Q50FPDm9bVsL3FjXWVhj3LIaXk+FCYJreZJrcqGO80qmhcBT21yvDsso5mKioqjwxzrV3eFWY+VFRUVAA0GoFBpyGczGMyLJzJshh07OvyYTfpCKVyXJyIsb7ewfWZBKXKfNmOJdpUi961lLxrIBOBwZer261v+lcUDQ4lI2/gRZrcZiYiGd66oR6jTsPFiRgzsRyNLnN1rlGjEdQ5jAwFb+RDbmtxcXY0uui11NiNzKotqq+JfLHMlcl4xQU1xcYGBxoBBq2GmXiuKhT3diozig0uM6FUnmNDIfZ0elecNVyJZK7Ikf4g07EsB7r9AFyZjlcjOm75+Ivfo/vrT+Pt+yfKGgNDmz9JseNNrDn6STQTJ8lbain+3JeJvf3TfPF8kn86NUat3cSeDi9XpxLs6/Sxv7uGn16b4U9+eBWf1cDH93fwjs0Nt2XYsxJSSo4Nhmn1WmhwmV/z8VQWo4rGVfALj7cC8PfHRu7zSlRUVO43/3R6DID3bGu8zytRUVF5PbCu3sGRgQD1zqVb7prcFt6+sYETg2FODkfY2OCoOpnaTXpsRl21+gjKrGRuzbuVG/NaVDG70R74PQDKz/8nhJQ4zXpi6QK7O734bAaODgYJp/MIAcVKBbPeZSZbLJPIKlVLq1GHSa8lmFwoEIUQ3IFz+0cOKSXjEaV6eGY0gteqp81rJZ0v8vfHRollC3TX2qpmNg2uGzOK/bNJBgMpnuz2Y9LfvhFMrlji5HCYq1Nxdra52dDg4NRIhFJZsrfTd+t8w0wE+a1fx/aNX8CUnSVds42ru/4rTVPP4T31vxClPPktv8SJt/+Az06v4fhgmHdvbeD925sJJLKcHAnx1Bofs4kc3zgzxqXJGH/wMxt4++YG9K/C2GY54tkCL/UG6PRbqXeqgvFuoYrGVfDe7crJ4bfPTd7nlaioqNxvvnB0GIBf3N16fxeioqLyusBm1DEdy+GzGpfdp9FtxmnRs6bORt9skkuTMS6MRSmXJRsalOrjXJuqViPI9LxLeeC170LxhhurePzXKNvr0cxchEvfYE2dnWvTcQDet72JTp+Vv3yxj0aXmamKGU+zx4JJr1kwy7i50cnFiZg6lvMaiGWU9tODvQEmI1n0WkGpLBkKpSmVJdlimXdva+BtG+sXmdlIKTk9EqZUluxq99y2GUy5rERonByKsPb/b+++w+PMqsOPf+/0GUlT1LslWe7d612X9fZlFxbYpQUWQgsttORHEggQEiABwgIBEiAJPUCAZQm97LK9295d915k9d6m93J/f8xYK1mSLduyRrbP53n0aMr7zpwZlfc9c+89p7KIqxuKSaU1Tx4form8kMUVRWd/kGMPoP9zE2rfvaQMVrrX/R2+sqtZ/tzfYx46RLKonseu+S7fL/4Q1oJi3ntDE3etreHEYJinjg9ydCBIfXEB/mgaswGcdjPvu7GZghmMbM7UqVYhh3sDbL3AtZDi7C5s8vAVYiZD90KIK0Mwli0kISW8hRAzVemy0j4SZtE0J+tuhxkFZDLZ/q/XLCjml3t6CMaSKIOixmXj+bYRrm0uw2RQJDzNULESBg5C6+Ow+PbsA5ntGG76BPzugyQf/mdsy+8kHE/jtGdP995zfRMfvHcvR/uDuOxm6oodmI0GjMpALJkmndEYDWpCUZxlVc6xOK0mw1iLDjFZIpXhxGCQjpEIoXiK0kILNpOR4kIztR4HNrORVDrDMy3DrK11TzndNJHKsO3kMMurnOecBGmtaRsO0zkaYXm1k5U1LgC6vRHahsNc23zm6qgAREbhTx+D/fehgEH3GoabXsOCEz+gINiGRnG4/s0cWfZXbFxaz80ex1iRnL1dPpx2M5F4ijdsqONof5BIIkVJgZXbl1edV9uM6QRjSXZ2eFlcUTT2OsXFJUnjOcpk9HmV/xVCXPrkU3chxLnKZDSlhTb6/LFpk0alFOVOG+0jYTwFFkwmAzctKWMgEGd5tZOOkTA9vii/2t1NY0kBxYUWWPGqbNJ48FcvJo0Aa94I27+Beego0ee+T/mCNzGQ679oMBh49bpqHjkyyNLKIjY1lQBQXGDJJRyhsVZjNW47bUPhCUmiy24mEEtK0jiO1ppj/UF2dWb7Cla77TSUFFBXbKfotEGHRCrDsy3DXNXgmXJAwh9JsqtzlI2NJedcFGYwEONwX4CGkgJuWFyGUmosmTMbDWxtLj372sEjfyDzh7/BEB4kZbBxpPzluFNDLN/9qWx8hU2c3HwPTetuYrnDQjqjea51hBfaR2kuL+L6RWV0eSMsKHbQMRphY2Mx33m6lbduXoDdMju/M1prDvcFCMZSbG0ulSrmc0iSxhlaX+9md6ePR48O8pLl0tBbiCvRqf6Mi8oL8xyJEOJSMRyKU1ZkIZXRDAZi044euexmfJHk2PVyp4224TDhRIqmskKaygp56vggw6EYHaNhRgpvZD2fJX3kDwyP+ihxOTEZDWA0wU2fgJ+/BcPTX8G96M84Gn7xcSuddl65uoqfPt/J1uZSFlUU0VhawKFeH76oHksaAdYvcLO708uWhdmetE6bmUA0SXnRlT0NMJZMc7jXz94uH8m0pr7Ywe0rKikpsEybmMWSabadHGZTUwkOy+TT767RCJ2jEW5YXH72tYbjBGJJ9nf5cTvMXL+obGxgI5ZMs6N1hKWVTiqnWU87ZrQV/cDHUCcexAAECpvo1qUs7/8NRtKkjA76V/8lxS/5MOsdhQwF4zx+dJBjA0EWVxTy/hsX0uOL8UzLMNVuO83lhbjsZh45PMjKGhdO++wUjgvGkuzq8NJcXsiKahldnGt5SRqVUsXAfUAD0A68XmvtPW2btcB/A04gDXxOa31f7r4fADcA/tzmb9da772YMX/gpmbe+cOdfP2xE5I0CnGF+t4zrQC8Y2tjniMRYm5c6PFawGgkQXmRDZfdzI7WkWmTxiqXjZ1eL8l0Zmz0ZP0CD9tOjnDD4mzFy80LS/nt3h7W13toKqtFP78aY/9+MiceZVfZjaRzsyGsjq2sLFuJdegg/qe+TeHSvyCaSGO3GKkrtmPwwqoaF/e90MXf3bYEu8VIIp3dV2s9lvg4LCacNjN9/ihVLjtOu5kub3SK6C9v4XiK/kCMHm+UztEIiVSaprJCcvfqEQAAatRJREFU3nh1PfYZjAiG4ymeaxthy8LSSaO0WmsO9PhRKLYsLJlxJdFYMs2+Lh9Gg+KaxuIJ004HAzEO9QXY3FRy5lHhRASe+Sr62f9ApeOkDRYCRg+2cD/LdStaGRhZfDfOl32KEkcFxweC+LoGGQknKC+y8vYtDdjMRnZ1jPLMiRHuXFtNY2nBWOsLpTRXN5TM6PWcidaao/1BvJEEWxbOYIqtuCjyNdL4MeBRrfU9SqmP5a5/9LRtIsBbtdYnlFLVwC6l1INaa1/u/o9orX8xVwHfvLQcgP3d/rNsKYS4XD14aACAV0vlVHHlmI3j9RUtkkjjsBgx5tpvRBKpKUeaKp02DAp6vNGxXnxmo4Faj5224TCNpQWYjQaWVTo53BegqawQtfI10L+fqq77qdr42rHHiiXTBLd8FOtv30LD0W+xq/ROfh6Ms7zKidtupn0kwt1X1/GvDxzliWODvHRlJZBdW+mLJCestVtR7eSJ40OUFVqxmY1T9nC8nCTTGQaDcfr9MeLJNIlUBm8kgdFgoKzIwstXVZ1T6wt/NMnuTi/XLSqbNJUyndHsaB2hvtgx40b06VyRm3A8xZo694RprFprDvUGiKcy3JibojolreHoH8j86eMY/F0oIKksaK3wJLPHuXDt9Vhe9q+MmBo4PBTDbvZjMRpAKW5cUk5xgYVEKsMPt7VjNCg+cNPC7Eg3sLvTR43bRseIvuDei6F4ip3toywsK5ywvlbMvXwljXcBN+Yu/xB4gtMOQlrr4+Mu9yqlBoEywDcnEZ7m9KpWs9FTRghxaZL1POIKcskdr+ebWDKNNTcysrzKyeHeABsaiidtZzIa8BRY6PVHJzRwbyot4MnjQ9QXOzAaFKVF2aI6/f4YlctfBY98Go49AMkomLPtBmxmI7a1r4RdV1PQ/QKbR35J94r3sqraRSCWBLIjQQYU+3v8jITimEwGrmkopm04hKfgxfiUUqyv87C708c1jZPjngvxVJqu0ciEqbOzQWvNaDhBnz9GIJqdwmsyGnDZsqfHGQ0Oq4kVNS5KC6efejqdkVCcg70Brl9UNmnK6anRx6sWFOOyn73gotaalsEQvf4YK6qdlBZOrMYbTaR5vn2U5vJCas7Qp1APnyD++49g63h8QgsFs85W4Q0ULSR+0z9zvGgTKqZYWGampMDCgR4/C0oKWF3nRmvN8YEgDx3q59rmUtbVe8Ye52CPH4/DTDoD9TNMhKd7vccGgoyGZXRxvshX0lihte7LXe4HzjjfUyl1DWABTo67+XNKqU8CjwIf01pP2XFWKfUe4D0A9fX1FxT0yhonB3sCPH5skJuXyhRVIa4kuzpGAc54MBbiMjQbx+vx98/aMflScirZKLCaiCUzY1VKT2cyGEimMpP2XZVrgbG2zo0CllQUcWwgSNGCOgqq10PvbjjxECy/a/yOcPM/wo/uovnE9zla+3p6/AUsLCvkpSur2HZymBuWlFFoNdEXiGJUEEul2dPpI5rMYDEZWFDsoKzIisthxmY2MBCIoZjbD83bh8N0jEbYsMBz9o3PIhxP0eePMRyKk8loUNkiQLUeO6YSB23DEfzRJMF4dh1p8TmMKJ5uMBjjeH+I65pLJxVQ7PfHODYQZGtz2VmToUwmmzwNBeMsLC8cm6o8XudIhPaRMBsbi6f8UFNrTd/wCJknvkT14e9h08lJ26TspWyvfw9q/VupLXGyudhBIp1hb5cPq8nAdbnEdzgU50CPH284wZ1raqgveTExPNYfxGhQNJUV8vSJIbY2l8707ZogHE+xs8NLU2kBSytldHG+uGhJo1LqEaByirs+Mf6K1lorpaYtSaiUqgL+F3ib1vrUf9KPkz14WYBvk/3U81+m2l9r/e3cNmzYsOGCSh9+6JbFvOtHO/nyQ8claRTiCvPFPx0D4CO3L8lzJELMrot8vJ5gNo/Jl4rTk6xFFYW0DIZYUjl51KzCaaVrNMJIKE7JuJGkkkIrxwdCRBIpUICCzU0lPNsyzHXLX4Wpd3e2iur4pBGg8Qb8FRtxDTzH1uGf8yf+goVlhRgNCpfdTK3HzjMnhllcUcTeLh8lBVaWVTnZvLCEeCpD52iEE4MhAEoLLRzuDTBXRaRjyTQ7271UuqxTJkpnorUmmkwzGk4wEIgRT2ZAZddoVjptNJYWYDQoArEkJwdDHOwJYLcYaS4rxOW48DZr/f4YrcMhrm2evEbxUK+fRCrD9YvOXM00ndEc6QswGk6wpLJoyqmZ6YxmZ/soTruZ6057vExG0+2N0j0apqTzfpp2fx5zuG/SY2SMVjoW/wXbq97CqzYtxWExEU+l2dPlI55Mj02BjSXTPN/mw2zM/kZvWVg6ocDO8YEgqUyGFdUuQvHsFOxzHZlNpDIc6MkWF9rUVDyrLTrEhbtoSaPW+tbp7lNKDSilqrTWfbmDzOA02zmBPwKf0FrvGPfYp37r40qp/wE+PIuhT+uWZdl1jYd6A3PxdEKIeeS5tuxI451rqvMciRCz62Ier8VkFU4bx/qDUyaN1W47/YEYrcPhCUkjwLp6N7s6vCypLCKjwWIysKmphOfDN7AF4PiDEA+BdVx1Z6XoXPM3rHrobjz7voP5ulfRMVLCgpICllc52dE6SiyZYU2dm5bBIM8cH2J1nZuhYJxyp43FFUUsrihCa81gME6PN8oTx4fYvLBk1looTOXEQJCBQJwNDZ5plwOcSgx9kSTeSIJgLEVmXEbrsJjwOMysqHZNeAxvOMHeLi+xZIZCq4nm8sJJrTEuRLc3Qrc3yuamiQljKp3hubZR6jwO6qunn7aZSmc40hfEF02wtNI5bQ/C0XCCfV0+1tW7cTssY/t2eaP0+bLFihp0N5u2fRJD25NTP8bCV2F4yado8xXw2uZStIad7aMk0pls1VObObdO0o8vkqS+2EHLUIiNjcUT1uUeHwiSTGfGKpoe6w+c0/rDTCa7FtMfTbKq1jWj6bpi7uVreurvgLcB9+S+//b0DZRSFuDXwI9OL3gz7gCmgFcBBy96xExc1xiMJWf1n4wQYv5KZ148EZE+reIKc0HHazG1CqctuybxtFYINrORTAbimckDtTazEafNzEgoDrnRS7vFyMoVK/BvX4dreA+ceBBWvlgQR2tNsOJqWHgznHyMu6K/4dv7/5z33ZAtWuKwGnHajXSPRtjQUMy2lhEiiTSBWGpClVelFBVOG26HmWgqzfeeaWXrojJWVjvHip/MBn80yd4uHw0lDrYuKkVrTTiewhdN4oskCERTaCYmhm67mRq3HafNPOX/Z62zrU7aRyIk0xncDjPLq1wXJentHIkwGIyxsbF40jnjC+2jZ1y/mExnONQbIBRLsayqiFW1UyeLp4rdRJNprl9cRkZrWgaD9PvjGAzZdYSbaizw1Bdgxzcx6NSkx4hXb8T68s/jqlrP0yeGWF3jYn+3n1Ras7LGOXZ+2++PcaQ/wLJKJwrFQCDGDePaekA2wU+kMmPJbTqjiSYyUxZ7muq1nBwK0eOLsbzKOe1rFvNDvpLGe4CfK6XeCXQArwdQSm0A3qu1flfutuuBEqXU23P7nWqt8ROlVBnZ/5p7gffOVeBv3lTPj3d08vXHWviHO5bN1dMKIfLoR9vbAc55ipQQl4ELPV5f8cYnOac0lxey/eTIlP3zCqxGUmk9aYoqZCuZ/vFAH83lLxbKcdrMhFe9Fh7fgz74K9S4pDGeymSn+N34cTj5GOad32Hx7W9gZ8co1zSWsKLaydG+IMcGQrx0ZSVPHh8iGEsSiU9dITWZ1tR5HFQ57Tx8uJ+nTwyxtNJJfbEDm9mQLcBjMmI1G7CaDJNG2uKpDIlU9ns8lc5+T2bwRxMc6Q9gNhppKi2gxxelJzdaNj4xXFY5dWJ4ukxG0+uP0jUaJaM1ZUVW1tS5Lup0x9ahEP5oclKRo25vhLbh8JTVUyFb5OdQb4BoIs2KaufYqOFUYsl0brTSjsmo2H5yBJNR0VBSwLXNhaA1gRfuJfH4p7DFhiY/l6sJy+2fxrrsTgLxFNsOD2AxKlqGQqyqcY1VOh0JxTnUG6CsyMq1C0t5oX2UWo+d5dUTRw9PDASJj0sYAfZ3+yZtN5Vub3bqc3PZ1Os0xfyTl6RRaz0C3DLF7TuBd+Uu/xj48TT733xRAzyDD9+2hB/v6OTbT7VK0ijEFeKff38YgM/ctTLPkQgxty70eH2lS6QyUyYKRoPCZjYQjqcmtSRYVuXkhfZRTg5NnqJqMCiaygroGImwrOrFE/WCda9FP/5P6OMPQcyPsmXvC0STuOwmKL8Gmm6C1sfZMvRzHjG+c2ykc/0CN7/Z08MdqyppLivEZDBwcii77u70Ii3J3OtZXetkRY2TZ04Mk8pk6A/EaC4rIBxPMRJKEEuliSczYwmzQmE0KKwmA1azAYvRgNVsxGRQ9PmjGJXizRsXYJ/B6NR0Ysk0naMRhoJxlIIql52rGzyzOhI6nZbBIJFEekIVUa01+7v9KAVbmyevX4wl0xzsyb7PK2rOPiWzZSDI9tYRaj0OhkMJGkodLKkoQilFOJ7iyP7nqHj6HykZfmHSviFnM6Yb/x7b2teBwcihHj/bW0dYXuVkbb17bFTQH0lyoMePy27m2uZSAtEkz7QMcXVD8aTZdVMljJFEilgyc8YCQkPBOIf7AlS7bGduCyLmnXyNNF6yxn8CJK03hLiyjK8SJ4QQZ2M0qGyVziksr3ZyqDfA1aeNTNnMRgxKEU1MPdpX63awu8NLMj0uIXVWo+o3ozq3ceTJn7PwlndiMRkIxFI4T53s3/BRaH2cgj3fpeyVf86R/uxI0tJKJ/FUJ61DYZx2M0rB6loXjxwZ4I5VVROeOxRPUZhLcq0mIzcvLedgT4C24RCPHAnzqnXVuOxTJwyZjB4bJUymMxzo8RNLprlqQfHYY54rfyRJ63CISCKdrfZa4mBReeGcnpsd7Q+QzmhW17rHbkumM+xoHaGxtIBaz8TjRjSR5kCPn3RGs6rWdcbXHoglOTkQYlenF5fdzB2rqsY+SEhnslM7B4eGqNr9VZaf/NGk/YPupXg3fIi6La9HGYz4o0l+sasTt93Mn29cMDZFNxRPsb/bh81sZGNTMWajgZbBIMOhBDcsLp9U6bdlcHLCCLC308f6aarcBmJJ9ndlE9KtzaVTVg8W85skjefhVOnr3+7t5VXS5FuIy9ojh7ONjhvH9U0TQoiZMBoU6WnKjTosJjIZPeVo46KKQp5vHWU4FJ/Uj89sUjSWFbKvyzdxKuTK10DnNhYNPcxTLXeyoaGYQCxJrSfXJmjBZmi8HtqeorH1xySu/fBYG481tW62nRxmUXkRVzV4ePr4EKPhBN5wYkIje380OaEJvVKKVbUuVtW66PNHue+FLuqKHbhsZiwmA6mMHitOc6rozJG+ALFkhpXVrnOuVJrJaPoDMTpHI6QzGqfNzKKKovNOOi/UoV4/JoOBFeOmY/qjSXZ1jE4anQvHUxzo8aOAVbWuKdf8ZTKavkCMrtzrS6QyROIp/mxDHS67mXgqzYmBIIPBOJlUnIJD93LNwS9gyvVYPCVStoaWpe9jwabXUl9gIRhL8lzbEK2DYV65tpoqV/Z3IppIs7/bh8GgWF+fLTqUzmi2nxyhrMjKpqaSSTG2DIaIJjKT1h8OBeMU2kyTChfFkmn2dmWrrl7TWCz9Fi9hkjSeh3/7szXc/u9P8aH79krSKMRl7iO/2AfAF1+3Os+RCCEuN2vq3Ozu8LLltH525UU2bBYjrUPhyUmjMbteUJMdvRkbSVx+Fzzw95haH+P6u4xs7/LhiyRZV+d+cecbPgptT1F5+HvsXfo2osZCook0Syud7Ov2cqQ/wIYGD3XFDryRJPu6fdy4pHxs91A8RdE0CVqVy867tjaxo22E+lx/R5PBgNGgGAzGODEQ4lBvgOVVzklJ8plMmHYKVLhsXLXAM+W037m0v9uHw2KkufzFKrgdI2F6vFGuX1Q2Ni02GMtO+TQbDaypdU8qwBNNpGkfCTMaToxNq11b5+Zgj58im4n1C9y0D4cJxVMYlUKhyRz8NVcf/Ay2lH/CY0UqNtC58oPEF9zI6jo3gViKbS3DjITjFNnMvGNrIyajgXgqzYFuP6mMZvW4BDYQS7KzfZT19Z4p11ZmE8b0pITxVIXV6xe9uDYxmc6wvzs7/XZN3dRJsri0yE/wPIwvky1TVIW4vHkj2SbIp08hE0KIC2UzGym0maYcUazzODjWH5y0j8mgSKU1Vy3w8HzbKFsX5RLOwvLsusWTj2I68mu2Xv0u/ndHB3u7fKyudWenAzZshQVbUR3P4Dn0Q5bc8Qn2dHlZX+/hkaMDXNtUynNto2xZWMJjRwdZXl1E23B4bKZFRuszFqIxGBSbm0rY2+UjHEthMCj6/LGxUauZTkn0hhO0jYSJ5nHa6Zns6fTidljG3hetNXu6fFhNhrEPAAaDMY73h7BbDGOjeKe2HQrG6RiNkEhlsJmNNJQ4WFqZXZ84FIxx/4E+nDYzdouR9uEwFpORVEQTPvEYWw99Ekd0Yr/FQOVmwpv+lmO2NaxbUAwatp0cwWIykNGaxRVOllQWkUxn2NPpHUv8xo+Etg+H6fVNTHjHaxnM9gkdPw33lJND2d8Rg0GRSmc42h/EG0mwusY9K30vxfwgSeN5urrBwwvtXn68o4O3bG7IdzhCiIvgTwf7Aahx2/MciRDicrWi2sUzLcOTKkg2lxeyq2PyFNVTiZPFZKDIZpo4hXTN3XDyUdh/H+qad9NcXkh9sYNnW4YpK7KypKIIww1/Dz96hrqj36fzmvfgsNgJx1PEEmncBRZKDYpdHV7W1bvp98dQSlFf7JhRwqe1ZigUJ57KJg7lRVZuXlp+1mQvndH0+qJ0eSNoDW6HmSUVRec0IjkXtNbs6vBSXmQbW+MeT6XZ0TrKkooiKpxWWodCdHmjlBVa2bwwmyjHU2laBoMMBuJooKzIyqqaF/tHJtMZTg6FeLZlhIzWbGkqwW410eONMhiMYx46xNW7P0qB/8SEeHyV18KNH+egcRllRRYWWU0c6PZTYDVS67bTOhxmTZ0bl93MwZ5sr8WVNRMrtGYyml2dXgqtpkkj3qecHJo+YUylM/T4omxZmP2wIBRLsbSqaNr+kuLSNb/+Gi8hX3n9Wq774uP8028PSdIoxGXqvT/eBcC333pVniMRQlyujAZFrcdOx0iYBSUFE25vLi9kT6ePlyyvmHLf5dVOXmgbffFkf+nLwVwA3S/AyEnARUmhlesXl9Hvj/F0yzA1rvUsrN+MsXM7asc3WfXqT/NMyzCK7EhiXXEBFpOBHa0jhGIpbllWwf5u34TKoKfzhhO0DIWIJzOUFVlZX+9hU1MJ3d4IT50Y5uoGz4TpiVprBoNx+vwxIvEUqGyBn42NMx+NnGtaa55vG6W22DH2QaI3nGBvV7b4S+dIhOMDQRpLC7iuuQR/NMW+bh/RRBqz0UB9sYOFC18cLQ3HUxzs8eOPJokmUvgiSTY2FhOIpRgIxkn6ItjDPVz35F9gC3ZMiGW0Ygvc8kkGilYwGIxRZDEyGIxjNChW1jg50OPHZjZyw+JSjg+GONjjZ1mVc1IiF0mkeK51lFW1rkkj3aecHAoRiqVYM36a87j35MnjQ5gMBl5oG2X5WVqGiEubJI3nafxC8AkVzIQQl4X0uIqHK6rlE1MhxPkxquyUvTO1fmgqLeDJ40PUeRwTpn9uWFDMfz7Rwi1LyzAYJu9vNhowm8a17rAUwPI7Yd+9pPbci3XR+8e2rXTZqHTZ6BqNcHDxB1nVuZ2ao9+js/c91LidvAAMh+IsLCukwmnj+kVl/PT5DvZ1+3DZzQSjSRTZarD+aJKRcAJvJEE8mcHtME8YOTul1pNd2/hCmxe3w4zJqBgNZYu2dI5GePnqqkmtHOarF9q91Jc4xorItA6F6BiJYLdkW1g0lxdSZDPR5Y3QORqZNFqqtWYknKB9OEw8lcFuMdJY4iAQS9IfiFNf7MAXSZLMZLDHBrn2gVdijI5MiGG0Ygvxm/4Fe/0anmkZJhMNUlpoZUGJgyKbmX3d2XWs1zQU0+2L8nTLCIsrCllaObFvotaaE4MhhoJxtjSXTNu/svUMCWMknuLeFzqpcdu5pnFySw5x+ZGk8QK8YnUVf9jfxz0PHOWfXrE83+EIIWbRN588CSBNh4UQF2RxRRF7T690ehqlFMurnBzuC0wYDTIYFBsbS3j82BC3LJt6tHFldbai+zWNucdf/QbYdy/qwM9xrvzrSdvXFTuo2/oKdMt1mNufJvTE1whs/DBdoxEeOdQ/9oGZAhxmI7vaRykvsvF828hY/z2X3UxJoYX6Yse01TATqey0xX5/DIOCtuEQBqW4ZVk5NrMJdXLkkkk09nR6qXLZqHLZ0Vrz6JFBOkYjLCovwKgUaTStw2Fq3Pax0dJkOsNQMM6xgSCxXPuU4kILK2tcpDPZaa4/eb6TpeVFLK9yEk6k8CT7WPyLW1Cp2ITn769/BYmbP01lTRPbjgzQv6ubq+o9LK9xYjEaONIX5EhfkDV1LnyRJNtbR1hYVjjl8csXyY6OLiwr5NpppqNCNmEMTpEwhuIpDnT7ONIX4NZlFRNGx8XlTZLGC3DPa1fzh/19fO+ZNkkahbjMfOnBY0C2WrIQQpwvT4EF44hiKBinrGjqKYAA5U4bxwdCJFKZCYnY1Q0evv1UK5sXlkxZgdJuMZLKZIin0tkRo8broagKo7+DUu9eqLx+yudTN/0D/M/LWNbxE1J3foTeRWW0D4fZsjCbSGQymmRac+faGp4+PkSPP0NjaQGbF05uwwDZtX39/hj9/hjpjMZkNFDjyY5CnZpyGkmkeKHdS5HNTDKdmelbmFcHe/w47WZqPXaO9gX46fOdlBVZWVObXSvYUFqA02bCG0nS74/xXGt2dNBoUJQ7bSyrdGK3GIkl07QMhtjROkLXaASXw8yaXIGixmQLnp/cOum52xrfRObWf6aqtJhtJ0f43TOt3LCojJevqkIpRY8vyvGBIEsri/AUmNnd6aPWY+eGxWWT1pGmM5q9XV4AtjaXnnHku3UoRCCWYu24hNEfSXKo14/FZCCeyvCK1dWUO22z8A6LS4UkjRdgfF+gw70Bllc7z7C1EOJS0euLjl0+00meEELMxJpaN08eH+L6xWVnXLO3us7F/u6Jo5JKKdbVe3jq2DAvXVU55X4rql0c7g1k1x0ajLDqdbDt6zhP/BKWTZ00smALNN2EqfVxBh/5CjWr/5Y9nV4ymWyFVINBYTIqSgqt1JU4KHfZeOLoIPXFBdR67MSS2ZHEoWAcrTVmk4GqXDuM6RISh8XEdYvK8EeS/GJXF2ajgeVVznlbYfNIb4CRcJyBvji/39eLP5rkzzfWU+t2MBiKMxiIcagn2/bC7bBQ5bKxrKpoLGFLpDK0DYcZCsaxmg3ojKZtOEyVy05jsY1m79MY/+/Nk573QNO7Md36j7gdVo4NBHmyrZOVNS4+cGMzqYzmcF+A0XCCSqeNFVXObNEhp5XrF5VOWXSo2xvhxGCItbXuCX03p9I2HMYfTY6tYR0JxTnSF6TAauSqBR52d/pYVuWUhPEKJEnjBfrOWzfw7h/t5I3f2cG+T92W73CEELPgLd97DoB/ffWqPEcihLgcGAyK1bUu9nb5uGrB9AVlnDYzGZ2dAjj+g+k1dS5+v6+XzpEI9SUONHpCyy+X3UwoniKd0dmkdM2bYNvXMR78Jdz+ObAWTv2EN/0DtD5O+eH/IbL23RQXWDg5FGJRRdGEzVbVuPnR9nbW1Ln59Z5uzEYDNW47VzcW01RafMY2HFNxOcwsr3axfoGbI31Bgj1JGksLqHHb895Wwx9N0jkSYX+3j/aRME1lhVQ4rQRjSdbVeRgJJQgn0lQ6bayfol9kJqNpH8m2rzAaFI0lDjKZDI8fG6LKbeM1y124jv4MfvHxSc/9XOMHMVz/NzgsZobDCXr8cUxK8Yar64mnMuxoHUWjWVxRRI3bzoEeP/FUhmubS6f8MCKaSLOrw0tpkYUbpxh9PF3bcBhfJMG6eg+DgRjHBoK47RY2NWVHi59rG6Wh1EGFJIxXJEkaL9Cpimb+aPLFf9ZCiEuW1pqTQ2EA3rSxPs/RCCEuFyWFVtpHIgwEYmc86V5T52Jnu3fCejOryUiVy0bLYBCXw4zLbiYQTU0YoVtSUcSx/mB21lPFcgJl63AO7YGDv4Sr3jb1k9VdA4tuw3TiIZw7/4PrNvwTjx0bpKG0gMFgnBMDoWxvRhTpTAaPw8KaWjdbm0vpz90/4I9RXGCh/jzWtllNRtbWuclkNG0jYbadHEEBVrORCqeV8iLbtGsmZ0ssmeLkYJj2kTDBWIqhUBxfJAlac+2iUvyRJP5IkjdsqKNwmjWYp6rBtg6F0VpTV+xgda2Lo31BHjg0gNtu4p1L01j3fA1++61J+29r/CDe1e+h2FlIOq0psJoYCSdYkCu6uKvDi8dh4aoFHuKpNAe6/dgtRjY3lUw5qqt1djTSH0myocEzqUDRVNpzCWO508aTx4coK7SyZWE2GR0NJ9jX7WNFtZPyIkkYr1SSNM6Cm5aU8fixIT5//xH+UdY2CnFJ+8/HWwC45gxFK4QQ4nysq3Ozv8fP8YEgy6uclEzR5sBqMuKymxkMxiacoC+rctE5EmFvl49Kp5WhUGxC0ljutHGkP4jWGq1hcNGbsknjrv+ZPmkE9C2fhBMPU3Lkfzlc9yb2dBjZU+ejvMjKiupsU/gim5lFFYU8dGiAm5aW0zocZlFFEQ6zkadODGWnagbjrKh2YbecPUEB0LxYodpgUCwsK2RhWXZENJpIMxiMsa/bRzKVXftosxgpL7JSUmDFYACFwqCy03cVoBRTjqRprYmnMgSiSQKxJL5Ikl5flOFQglQmg9mgKLCZURqcdhPNFQUkU5qNjcXs7wlQ5bKzrGrq5Uf+aJKWwSDRRIZyp5Wr6t10+aK0j4SJ9qXRyQivNT5D0Z57oXPbpP2fr38P2yvfxOqmauoKrSwqK2B3p58drSNUuewMBuM0lRVwXXkp0WSa3Z1ezEbFVQ2eaSuejoTi7O/xs6SiaMaVv1sGguzr8VNWaKXQmhqb5nqqYI9ScP2iM0+tFpc/SRpnwdfftJ6Vn3qQ7z7TJkmjEJe4f3voOADfeov0ZhRCzC6DQbG2zk0qneFIX5DDfQGWVjonrZ1eXuXkqRNDlC22jiVCxQUWDvb42bqwhG0nRwjFUzSXT5xG2lhSQPtIhGKHhcTSu2D3Z6F3D/Tuheq1xFNp/JEk3kgSbyRBJqNBVVFW9XIW9f2Bq05+g72V/0iR1URDaQEaCMZSFNnMeBwWUhmNx2GhZTBEKqMJxlK8cnU1BoMiFE+xv9tHOpMdaaty2c5YbCWb6k3NbjGyoKRgQmXOaCLNQCDGkf7AWGKsIftda8Z1SZpAa00ynSEUTwFQYDWxssaFy26mbThMLJmh0mWloaQAfzTJ0f4gGxuL2XZylMaygrGejKecKmgzHIwTSaYosJgYDSc52h9guMpJWaGFwpGDrOj8JZ6WX6MSoUkxPVP3lzztfhWbVyzkDo8DfzRJjzfK0yeGWV3r4qUrK3HZzSiliCRSPN82CsDaOve0o4bJdIY9nT7MRjXjBG84FOfp40ME4inuWFk14fdwIBDjcF9gRusgxZVBksZZUGg1YTMbiCUz/H5fL69cU53vkIQQ5+HUgRmQg6QQ4qIxGQ2sqs22XjjaH+BIXwCPw4LbYcbtMFNoNdFQUsDJoTDN5S+uR6wrdtDrj7F1USnff7aNrtHIhL7RdcV2Hj82yIjNTDJtZKDx1VQc+QH9j/83rZs+h9VkwGW3UFJoYWFZASajAX8kSf+Nn0D//GGKWn7Lloa38cRxA8uqnRTZTIyGE2Mx13hsHOjx0euLYrcYuKbxxUqqhVYTG5tKSKYz9Pli7Ozwks5orCYDtR4H5UXWc177OJ7dYqShtIAGzjwNVmtNIJqi2xfBH0miyU4NXr/Ag8VkoGUwRK8vRjCWYnm1c6wirT+S5GBvgA31Hp4+Mcz6es/YSO6pn9PuDi++SHb9ZTCeXfvotJmocjtY4kqhXvgOJb2/YVHw6KS4EsYCHih9O08U3sH65lpuKC/EqBRKQTyVodJl4/YVlWPvUba1hR+TUbG61n3GEdz24ez02nX1Hlz2MxcVSqYzHB8IMhpOkEhlqHbbeXVTyYT7d3d4cVhMM1oHKa4cSutpPpq5DG3YsEHv3Lnzojx261CIm7/8JADt97z8ojyHEOLiavjYHwH45fu2nLFYxYVSSu3SWm+4aE8gxCXgYh6TLzVaa0LxFL5IdvpkKJ5CozncG2BBsYMKl410RpNIZdjb5WNVrYtDvX6sJiMOs5Fqz4ujYe3DYRRw3eIyymPtWL61GSyF8HdHwVo06bkP9vip9dhxP/3PsP0b9BZvZNuW77KhoYRKl41DvX6uWpCdrv/H/X2cGAzwji2N7O8JUF/soNZjP2MyGEum6fZGGQzE0GRH+uqLHRztC7DlDH0Cz+W9Gwkn6PFGCedGE0+1yHDZzWgNXd4I3d4oJoOiubxw0rTgWDLN9pMjrKh2cqgvwOamYuIpze4OL3u7fAA0lxVS6bISS2YwGhS1Hge1bivptmcIbPsenvYHMGQSk+IL2mvZVfs2+hpfRVNlyYTiOV2jEVqGQqyvezFBDcSSHOzxYzEaWFnjOuN6xNFwgoM9fqrdNhaWFZ4xwRsKxjkxGASyvUPD8RTDocTYsS6VznBiMMRgMM66ejfOS6SHpphdZzo/kZHGWdJU9uIngdJ+Q4hLT9tweOzyxUwYhRDidEopimxmimxm6sYtp97YWMITxwap8dhxmE2YjQqr2UhjSQE2s5FllU7aR061SHBjNRlZUe3id/t6qPU4gOVQvxk6t8Oen8Cm90567kA0iavaCdf9Hez+X6pHn6Oy/3GO2W+jvthBPJUhmc6wr8uHx2Gm0mnDm1vLV2Q3UV/imPSY49nMRprLC8dGTIOxJF2jUQ71BkBlp6nazAaKbCYKrWYKbSYcZuO0iWgmky060+OLEk+mgexIYlNZAUXjEp1YMs1zbaPZ6bIeB5ubSjAYFMl0Bl8kQSieIhxPE4oneer4MNVuG637Q1Q57XznqTbMJgPr6tzcubaKfn8cBVQ47dkkOdRPes9/kdz5I6zBDqbqXBkoaqZlyV9iWv0adCTN7XUeinMzWPzRJPu6fFS6bGOjeb5IgkO9AWzmbGuL6dYsQjZZPNwbwGk3sWXh1MVwINvy4/hAEG8kQUmBlasbijEbDbQPhxkJZxPGUDzFkb4AiVSGRRWF067fFEKSxln0/bdv4B0/2MkdX3taRhuFuMTc9tXsTIGvv3FdniMRQogso0GxeWEJz7eNjjVsX1ZVxAttXhaUOBgKxllW5SQUT/FCW7a1wpKKIiKJ9IsPsvkD2aTxqS/Buj+fcrRRKQWOYrjxY/Dgx7nq0Of5nedqDvTY6PVF2XZyhLW1bpx2E6F4inuf7+S91y/k6EDwnF9Tkc3M8moz/miSzQtL0FoTS2YIxpOE42mGgnHCiRSZ3Ey4dEbjDScIxFKYlAKVbdlRWmDFbjGS0Rp/NDk2jfaUdCaD1tlptT2+KD25/rsmo6LAYqLQaqK00IIvkmBZZRGxVJoat5NCm4nm8gKGQwnSGY3FmK1SatApOPEw+sEfok88jFGnmSqtC5eupm35+yha/UrWlbw4oKCUGhspNijYvLAEs9EwlgAWWI1c3VB8xmqxI6E4h/sCuOxmNjUVT5ssDgZjtAyEUEqxuKKQlTUvFsRpHQrhiySoctl55sQwdouRledQwEhcuSRpnEU3L60Yu9wxEp6wgFsIMX+NhhMk09kTFFmTLISYTxwWE8urnOzu9HLVgmKsJiPlTiupTHbtYH2Jg0Kria2LSunxRXn82CCJZJpYMp2d2rj0FVB7DXQ/D89+DW7+xNhjZwvhjHuyjX9Jet992Pv3su7Ef/LdvvfgtJu4pqGEo/0BUhnNwrICTg6FMBoVWkM8lT7jqNjZKKWwW4zZpKUo+3h9vhj9gRiZjMZiNLCmzk1xgYVUWqNUtqCQUSmMBoVh7PvU1VOnk0pneLZlmD8e6OP6RWU0lxcSiKaIxFOUFDjY1FSEAZ1NuLf9An34t6jIyLTle8LVm2lZ+l5KVr6ElcUTz/+0zk41HgnHWVvnpshmZigY52j/2RNAmJgsTtdmY/yoYmmhlWsaJz/m0f4AR/uCFBdYiCRSbFlYckHrTMWVRZLGWfbvb1jLh+7byw1fekJGG4W4RLzia08D8NGXLs1zJEIIMVm504Y3kuTkUIiFZYUsKi/kyeNDmI1qQtJW47ZTaDHSMxrj13u6efW62mzieNtn4Pu3w/ZvwNXvhKJKAGKnJ3wGI9GXfhnHD29jUftP+Mzb38r320vo9kbYMG4U7A6jgfsP9LGgpIDDvQHW1Z/blP50RjNVrnK4N0A4kaLKZWPDAs8ZE6nzobVmIBCndSjESDjOY0eHeOnyCorsZlx2C8urXNm4eveQef4XpA/+CmOoD2DaZNFXezMdy99L5cobWDNF/81eX5RjA0GWVhaxvNrJYCDGnk4fxQWWsT6I0xkOxTnSF8Btt0ybLA4GYrQMZkcVl1QWTRhVPNU/sms0QttwtuLtrcsqJ1XrFWImJGmcZa9aV8OH7tsLyGijEJeCoWCcXn8MgPfduDDP0QghxNSWVBaxo3UEj8NCcYGFtXVu9nX7ONoXZE2de2w7XzTJTcvKONYfZE+nD6VgaeV63EtfAUf/AE/cA6/8dyA7ihmOpxgNJ4gm03QMh7Gamyhb8hfUH/0ulvv/hnUv+RVOh4X93T6uWuBBKUV9sYMeb5SGkgJ+sauLCqeN6tNaU5xJNJmecjrkxaoHEYmn2NXhpWM0gsWYXT+67eQIH7ixiaayouxo2+BReOIXxPb+H7ZAO6fSs4TVg0lpDDHf2ONpZWCk/qX0r/4ADSs3scY6+XQ6GEuyt8tHaaGVGxeX0R+I8eTxIcoKrWxtLj3jCN/ZkkVfJEHLYIhYMkNpkWXCqGIwlqRjJII/mkQB5U5rdv1rlWtCQinEuZKk8SL4j7vX8v9+JqONQlwKbvq3JwD4pPRYFULMc9c0FPPk8SE2LyzB7bBQaDXR64uyutY1NjVzNJxgaaWTAmuUqxZ4yGjNsf4gJxb+FRuOPQC7f4S65j1Qkf2ft7SqiKFgHKvJMNY0/rnoh6jqfQjz4CHqd3+B6jd8laFgnCeOD7GpsWQs4at02XjVuhr2dfs4ORSizpOtpnq2EcJIIoXjIq6hy2Q0g6EYezp8dI5GsBgNrKhx8vJVVcRTaR481M8HbmqmlkF49jtw4JcweAgAG5CwlREtXkqhDmEZaYF4du1myl5Kb9Pria5+K03NSyid4nWeKhqkyRYyGgzGeOrEMJVOG9fNMFn0OCaPQobiKU4MBAnH07jsZlZUu1AKfJEkLUMhRsMJtM62PllQ4mBFtROlFMf6gygFK6olYRQXRpLGi+CutTX8v5/tBRibSiKEmH+6vZGxhs/v2NqY52iEEOLMDAbFpqYSdrSOcMPiMtbUuvn5ri66vdGxfo3RZBqb2UBDSQEdI2Gay4tYXetG12wk2vVmHPt/SOTet5F8+8O43G7Ki2yUF02cVul0ufDe9nXKfvlaqo98H/ZvoWz1n7G5qYTn2kYpKbCglCIcT1HjttM2HGbLwlJ6fVFeaPeS0RqX3UxjaQEFU4zCxRIZ7JbZOwVNpTMMBOP0+aJ4wwm6vBEcFhNr6ty8dGXlWELdOhSit7uNm30PUfuL+6HnxZYvGaubwZpbMNkKKA634up4euy+cMUGuha+iYK1r6GuzD3l2kmtNccHQgwEYqypdeGLJtl2cphaj53rF5VOu95Sa02vP8bJwdCkKavRRJpj/QF6fFEyWuO0mzEbDQTjSfZ0ebGaDLgdFsqLbCwqL5o01fVIXwCtJWEUs0P6NF4k9x/o4/0/2Q1I30Yh5qtTfRn/7c/W8LqraufseaVPoxDSp/FCDAXjtI+EubqhmI6RMNtOjvDGa+oB2H5yZKwq6baTI1w7vhdiPAjfuRmGj+NtfjUHr/kingIrC8sKJ0wXHQ7FGQ7Fse7+Ho3PfxpMdnjnQ1C1GsiOZj7fNkqvL8rVDcUE40lW17opHJcgesMJ2kbCROJpLCYDFU4rpYVWCqwmjvQFqHTa8ORaUJyLeCpNKJbCH00yGIyTyWg0EE+m0UBpoZUllUUv9jfUGgaP0L/zNxR1PopjYBeK7LmvNhcQXPAS+oqvpiwziOf4L1CBntx9DgYX3En/kjfTsGLTWB/FqQwEYhzuC9BcVkgynaFzNEJ9sYPG0oJpk8VoIs2RPj+jkQROm4WSAgvRZBp/JEGXN4o/msRiMrCg2EFtsQO3w4zbbjljddXxDvX6MRoUSyulhYaYuXnXp1EpVQzcBzQA7cDrtdbeKbZLAwdyVzu11nfmbm8EfgaUALuAt2itJ3dUzaM7VlWNXX7i2CA3LinPYzRCiNMd7PGPXZ7LhFEIIS5UWZE1t64tSHN5EY8fHaLHG6HG40DnEqJTyYrW+sXExVoEr/8RfOdmPC2/5rqlN+Cr/XMO9/mJJjK47GYWlhfgcVg4MRBCL34zBSMHKD/5S7jvz+Hdj0NBKcUFFm5fUcH2kyPUFzs40Ovn/3Z2sa7ew8Jcv0RPgWUsKYyn0rnm8iEiiRTPtY6ysbEYT4GFsiIrHocFo0GNJYSheIpg7nvmtMENi9FAkc2M026iocRB63AYBayscVF+qhBNMgYnHofjf0If/xPK30Vlbv+MwUKi6RbaK28nZXGzsOc3LNn5acgks7u6F9K58I1Elr2exQ21VJyhMmwonmJvZ7Z/ZY3bxsmhEI2lBWxZWEI8lWEoFCeWyBBJpgjHUyRSGQYDcQYCMcwmA/XFDkoKrDgsRgZDMYLRFEU2M7csq6C00HJO1WDHO9jjx2IysLhicnsVIc5XXkYalVJfBEa11vcopT4GeLTWH51iu5DWetLcTqXUz4Ffaa1/ppT6JrBPa/3fZ3veuf5U81Cvn5d/7RlARhuFmG9OjTL+8B3XcMPisjl9bhlpFEJGGmfD7k4vxQ4LpYUW/ufZdt65tYF93QE2LywZu395lfPFUbdT9v8cfvVuMFqyI4jV2f60vkiCk0Nhook0bSMhat127IY0mx5/I/TtBU8DvPE+KM9Wmt7WMsyW3EjmMyeGWVPnGtv/lLEkdqz+qOZgT4AV1dn+kr5okmAsSUZrTAYDBRZTtgWH2Uih1YTFbMBsMGAyKkwGRUZrOkciRJJpygqtNJUVYDMbMYb7sbQ+iunkQxjankAlI2MxZByl6EW30ebeTJsvxVXp/Xg6H3pxVFEZ8NfdQlvTm7Atvpna4gIyOrs2Mq312PdEKkMsmSEUT3Go108ylcFuNhKIp6h22SjLTfM1GRU2kxG7xYDNbEQBXd4oyXSGWo+DBbmpxF3eCN3eKEpBY2kBlU7beSeKpxzo9mMzG1gkCaM4D/NupBG4C7gxd/mHwBPApKRxKir713Qz8KZx+38aOGvSONdWVLuwGA0k0hn+64kW3n9jc75DEkIAP3muY+zyXCeMQggxW9bXezjQ7SeWSnPn2mq+9XQbNy568X+a02YiEE1OThpXvz7bf3Dn9+F/Xw2v+S4suhW3w8JVC7Kjg9FEmvaRCKm0xnbdt1j+xLuxDO6H794Kr/s+LL4Nk9FAIpXBYjLgKTCTSGVYO66S61QGgzGKC7JTSEnGQCkwTW4BobUmndGkMppEKk23N8rxgTBKaRYUF+CwGDD278P01CNYOx7BPnxgwv4hz3KOFG0hWL2FdNhLw+AT1B3+R5qTL84yidnKOVr5So7WvpbymmZcDjOxlKZtODzW/3F8L0iTUeENx/FGEjSXF5BMw6Lywikrx2qt6RyN0DYcxmExsrLGRYHFSK8/xo62EbSGOo+DzU2z1ytxX5ePAquJ5nKppSFmX75GGn1aa3fusgK8p66ftl0K2AukgHu01r9RSpUCO7TWzblt6oAHtNYrp3mu9wDvAaivr7+qo6Njqs0umtFwgvWfeRiAls+9bNZ7Dgkhzk0mo2n6h/sB2P7xm6lyzbxM/GyRkUYhZKRxNp0YCBJOpPFFEuzq8PK3L1mMUorBQIxALDV1EpGKw8/fCsf/BCi48WNw/d+DIXue0jIY5MRACLfDwvoFbnoHRyl68K8p7bgfrQyEN/0dg8v/AoezhEqXjXgqzd5OHxubSs4Y6wvto6y2D2Pd+0PY+xN4yWdg/Vum3DYUT3GsP0AkkabGaaEh3Y6hawd0PAsd2yA89OLGJjs03QiLb6fPtZqju59hReBpSgeewZCKjm0WKWok1vwy2ktvIlm5Dk+hjUA0OdZOZCrpjOZof4AebxRNtkLpoorCSQWEtNZ4I0lah7LtMOqLHdR6bPQH4nSMRMhoTaXLxoJix6yfD+7p9OK0m6X4orggeRlpVEo9AmNTyMf7xPgrWmutlJouc12gte5RSjUBjymlDgD+abadktb628C3IXuAOpd9Z0NxgYXrF5fx1PEhXvfN7fzmA9fOdQhCiHH+8se7AFhX785LwiiEELNtUUURXaMRjvUHWF3j4pe7enjtVTUU2cz0+KJT72Sywt33wtNfhsc/B098HrpfgNd8BxzFVLnsbD85gtthwWoy0lhdBm//KTz5BdQTn6dw+5ewvfBfHK99LaMb30dJTRORRHriGsrx0kk4dj/NT30La/+zL97esW1C0qi1pmMkQvewj9LgEVaF92Hp2QGdz0H8tFNAZy0svh29+Hb6S64mvPtXuJ6/j4qhD1OlUy9uV72OxKI7OFF8I52GOqLJNJVOG0VWM0U2Ew0lUxesSWc0R/oCtA2HUCgqXTaWVztxjKv86o8m6Rp9sS+i22FhWVURvmiKjpEwXd4IlS4bVzd4LtrAwe5OLx6HhcZS6Q0uLp6LljRqrW+d7j6l1IBSqkpr3aeUqgIGp3mMntz3VqXUE8A64JeAWyll0lqngFqgZ9ZfwCz6wduvpukf7mdvl48TA0GZZy5EngwEYjx8eACAn//l5jxHI4QQs6eu2IGrL9uSwW418Nu9vdy5popoMj39TgYD3PARqFkPv3wXtDwC39gAa95Iwbo3k0hZmTAjTeVGJOs3wVP/hqn9aZa3/wjd+VPiZatpNldxYk8tBk8DSilc8R4KIz1YQ12okRaIevFAdlRw1Wthwzug5ioAwkEfPQefxtb7HJXe3Szo341KnZbwuuphwRZYsJlk7Sa6VA39gTgA5WkLZaM7cQ1uRysjNF6PXvoKBmtu4UTUjc1sYFmVkxVTtAA5XSqd4WCPn6P9wdx0zyIWV2RbWgRjSY70BfCGs/UXnXYztR47yyqL6AvE6ByN4O1KUOWycU1D8UWfYbarY5TSQisLSiRhFBdXvqanfgkYGVcIp1hr/fenbeMBIlrreG5K6nbgLq31YaXU/wG/HFcIZ7/W+r/O9rz5nArzwIE+3ictOITIq1PFbz75iuV57cso01OFkOmpF8O2k8OsqHKxq2MUg1IcHwzSXFbIzcsqzr6zryubOHbtGLtp0LmKwLK7ab7prWCbonVDz26GHvoyZZ0PgD5Dcpoz6mgktPjVZKrW4UoNU+BvITVwBMPwcazhnrFWGGPKlkL95myiWL+ZqKOa1uEQvkgSo0FRV+ygymnDYFAc6vVjG9zHQroJL7iVY0Ez4XiKSqeNprLCST0Mp5JMZ9jb6eNgr5/yIivr6j247NnR2uFgfGxqaq3HTnGBBa2hxxelyxsBDVVuO/XFjhk914XSWrOzw0tFkY36EsdFfz5xZTjT+Um+ksYS4OdAPdBBtuXGqFJqA/BerfW7lFJbgG8BGcAA/LvW+nu5/ZvIttwoBvYAb9Zax8/2vPk+QJ06Yf2bWxfz/25dlLc4hLgSff+ZNv7lD4eB/H9wI0mjEPk/Jl+Otp0cZsvCUiKJFDtaR6hy2vnpcx28bkMdq2tdZ6/MqTX07obd/wsHfwnxQPZ2owU8jVDcmK2gOna5kecH4RpPJFtddfAIvo59uIItqEQECsvAXgyZJLFoBHM6gjHUN+VTZwxmIu4lRKs3Qv0WLI1bSNhKGArG8EWy7TCsZiONpQUUj+vveCp58uT6KPb5YzgsJpZUFk3oGzn1y9WE4ilGwwmeOj7Evi4/JYUWrlrgodBmQqGwmQ3UeOyUFVpRSpHJ6GyiOJqtzlrttlM3R4ni+LhfaPdS5bJRVywJo5g98y5pzJd8H6DGF8U58OnbKLJN3yhWCDF7IokUyz/5IAA7Pn4LlS7bWfa4uCRpFCL/x+TL0amkESCRyvBsyzAjoTgGg8JsVGxqKqWsaHKl0iklIhx+9Md4jt9HlXf2fk4Zg4WYeyGWyuWYKpZB2RIoW0ra3cBgOE3rcJjhUJxwPIXJaMBpN1FkNU2Z8BqUYnfHKCajgSKriSq3HbfdTFpDJld99fQ+j+Ol0pq9XT684TgbGoq5aWn5hPWKYzFnNN3eKN3ebKJY47FT65nbRPEUrTXPt41SW+ygZoqqrUJciPnYcuOKVFxg4R3XNvL9Z9tY9emH8j7aIcSVYsNnHwHgDRvq8p4wCiHExZBMZzCPWz9nMRm4fnEZ/7u9nWVVTpLpbBJZVmTBaDBQ4bRR7bZhna55vcXBSPOr2VZ4K++6pgy87TDalv3ubRu7nAyPYrYVgtkOZgfa7MCXMuFxucFsJ2GwsTfkxlq1nJKG1dQ0LkWlFYORBL5IEn80ifZrVCBIudPK+noPdss0MeVEEin2dXnZ0TrCunoPSyqLsJmMGAwK47hWGUalpmxnEYwmuf9gH95IkluWlbO8yjkpKY0m0nSORhgJZSey1XocbJrF9hjnQ2vNjtZRFpQ4pmzzIcTFJEnjHPvkK5fz/WfbAPjeM228M4/rqoS4Evx+Xy+RXKPpL7xudZ6jEUKIiyOSSGM/rR+j0aBYXFnEsmon+7p8FBdYSKQyXLXARTCeZn93tkG9Uopyp5VKpw2HxTiWQIViKapddoYSFsoqV0HlqknPu7t1hA0NxWOjbgo43DJEWZGVgz1+DvUGWbfGTXGBhTDQ2e7DZjbicViodttYWlk0o0QsHE/RNhzGF0mSymQIxVO894bmyT0oz6B1KMRjRwdRCm5bXjlhamcmoxkIxugajZJMZ7CZDdQXF7C4ovDs03rngNaa7a0jNJUWyoefIi8kacyD7R+/mc2ff4zP/OEwr1lXg2fc3HwhxOwJxVP81b17AHjwQ9fnORohLj1KqWLgPqABaCdbg8A7zbZO4DDwG631B+cqRpEVT6WnTaCcNjPXLSqjazTCkf4ATx0fZnm1k6sbioFsa4nBYIyWwVC2bUauIM2eLi9LK4v4/b4ermkswZEbAYwlM8RSaeLJDC2DIcKJFDazkWQ6Q8dIhD5/jCKrkSKbiXdc20iF03rOVUS11gyFsv0NE6kMDkt2PWNJoYWWwRAvW1k1s+I2qTTbWkc51Ounymnj7qvrKMwtDwrFs20xfJFsu4wKl421dW4spvnVU1trzfaTIzSXF1LulIRR5IckjXlQ5bLzwZua+cbjLaz7zMMyTVWIi2Tlp7LrGO++uo4lldLqRojz8DHg0XHVzj8GfHSabT8DPDVnkYkJ4skM1rMkO3W5dXCHegPs7vBycijE8moX1S4bVS77pN61R/qC3LK0kn3dPmo8duLJDADFBQZsZiNWk4EimwlPgZnOkSgWo5G71tQQTaX49e5e3njNgnNKFlPpDN3eKL2+KBooLbSyqsY1lgy3DAbxR5NsbS496+jfaDjBw4cH8IYTrF/g5r3XL0QDvb4oB3sDpDOaAquJBcWOKaenzhfpjGbbyWGWVBZRXiQJo8gfSRrz5MO3L+Ebj7cA8MU/HeXvX7o0zxEJcXn5+qMnxi7f81qZlirEeboLuDF3+YfAE0yRNCqlrgIqgD8BUuQpD+KpNE77xAJ76YzGcFoyZDAoVtW6WFRRyM52L3u7vBzpM+BxWFhS6ZxQcTQST2G3GFlUUUiPN8rKGteEx+r3x9jT6aWhtICrG4oJxJIc7PXjsBhZXeuc9NynS6UzDIcSDARihOIpDEpR67FPWjuotWZftx+rycBVC4qnfbxMRrO/28fODi8Wk4GblpbhtFnoGAmzvXUEg1JUu21ctcAzYf3nfJVMZ3imZZi1tW6ZlSbyTpLGPNr9Ty9h/Wce5r+eOMmda6tZWjlFDyQhxDnr8UX58sPHAXj+E7fkORohLmkVWutTPRL6ySaGEyilDMCXgTcDt57pwZRS7wHeA1BfXz+7kV7hYskMZUUTp6eG4qlp207YzEa2LiplNJzIrRVM8Mtd3dgtBlZWu1lSWUQqozEZFFUuO6PhBAd7/CyvctI6HKLHF6PSaWN5tQsFPN82SlmRlY2N2Yb27cNhev1Raj3ZdYPJdIbhUJyBQJxIPAVk11yWFllZWF44bZyZjGZH6wh1xY4p20skUhk6R8I83z6KL5Kk1mNnfb2bWDJD10iUIluKBSUFuOyXVsX6eCrNsy3DXN1QLNX2xbwgSWMeFRdY+I+71/L/fraXl/7707R87mXnPOdfCDGR1ppr73kMgH96xXKZziPEWSilHgEqp7jrE+OvaK21Umqq/gXvB+7XWnefbYqf1vrbwLch23Lj/CIWU4mnssVbxgvGkjjPknAUF1jG+h6mM5p+f5T93X6ebRliT6eX3+ztQSnQGc3R/gA/2JbimgUeajx2RsJxTgwEWV/vYUW1k3gqQ5c3SiyZJpJIs7fLy7JKJygwGQyUFlpYVF5IwVn6J56SSGV49uQwq2tclBRax15Try/GYDBGjzdCvz+O2ahoLC2koaQAp91MjduO22Get1NOz+ZUn83NTaVnrSQrxFyRpDHP7lpbw/efbWdfl49Vn36II595ab5DEuKSdv2XHgegpMAi1YmFmAGt9bSjg0qpAaVUlda6TylVBQxOsdlm4Dql1PuBQsCilApprT92kUIWU0ikMlhO++B5KBhnUcXM13MbDYoaj4Oa3OhgIJZiZY2LY/0BNIo7VlcTTaQ5MRAaS8gsJiPhRIrhUAKryYDdbMRtN2M1GwjHU2xeWHJeyVsonuL5thE2NZWM9U7c2T7KyaEQQ4E4ZrOBWreddfUeajyOaUcqLzWBWJJd7V6ubS6dvh2KEHlwefyFXeJ+8/4tNH78fqLJNF9/9AR/dcuifIckxCXpu0+30jUaBeCFT5xxlpwQYmZ+B7wNuCf3/benb6C1/vNTl5VSbwc2SMI49zR6UnIWjqfPO5nq80Xp8UYJxlK8ZHnlhMqsy6qcHOjx4zAbqfPYWVvnmbJya7XbxmAwTsU5VvwcCsbZ1+VjeXURPd4o7SNhukajZDKaxZVFvHJ1NY7LJEkcbzScYH+3j+sWlcrMMzHvXH5/cZcgpRTP/cMtbPzXR/nyw8e5YUkZq2vd+Q5LiEtKy2CQz/7xCABP//1NeW3ALMRl5B7g50qpdwIdwOsBlFIbgPdqrd+Vz+DE9MLxFA7ruY1Uaa3pGo3SNhLGbjaytKqIqxZ4Jm3ndli4blEZ4XiK3+ztIZXR1LjtNJUVTmiDUV9cwJ5O77RJYyyZxhdJ4osm8EeSpLVmIBBjNJxgSXkRuzt8oKDO4+C6RWXn1JPxUjMQiHFiIMT1i8rk+CXmJUka54kKp42vv3Edf3XvHu78xrPs+9Rtl9yibSHyJZZMc+tXspX+v/ja1VMWSxBCnDut9QgwqZqU1nonMClh1Fr/APjBRQ9MnNXJoRALSwtntG0mozkxGKI/EKO+2MH1i0rp9kZpHzlzxc4Cq4mm0kI2NnoYDCZ4rnUEFCheTHp2tI6Q1nrCbaf6QNpyU1nLi2w0lxVyqNeP1WhgcUURNrOR62rduByX/7lQ12iEHl+Ua5vPbyqvEHNBksZ55JVrqnni2BC/3N3Nmn9+iLbP3yH/PISYgaX/9CcArmks5vVX1+U5GiGEyL9ANHXWhCuZznC4N0AglmRRedGEfraDwThlRdYZPZfBYKDSZaPSNXlE0e0wU15kHStkczqtNT2+KL/Z04PLYebahaVUOK1XzPnPyaEQ/miSTU0l+Q5FiDOSCdPzzJdfvwazMfuPctPnH81zNELMf7d/9cVe4j//y815jEQIIeaHaCI9qZLq6fe/0D7KC22j1Bdnp36envDFU2lsMyzEovX0hXAbSwtoHQ5Pe38smWHbyRFuX1HJa9fXUumyXTEJ45G+ANFEmvX1k6cACzHfSNI4Dx37zMsAGAjE+dRvD+Y5GiHmr88/cIRjA0EATnzuZXmORggh8mf89M/DfYEJo4annGrlcCDXb3FLc+n0TePPoSFKMq3JZKbewWY2kkhlprwvkcqwo22E25ZXUOOxz/wJLwP7unyYDIqVNa58hyLEjEjSOA8ZDIqd/5it/PjD7R3c+3xnniMSYv7508F+vvVkKwDP/cMtmKXSnBBCoLUmkkhNaAgfS2ZHFg90+1lb5+aaxuIz9kpMpDIzrt6p0exoHSE+TWII4LSZ8UeSE26LJFI80zLENQ3FuB1nXjt5OdFa80L7KG6H+ZzaoQiRb3KWNU+VFlr5w19tBeDjvzrAMyeG8xyREPPHvi4f7/3xLgB+9p5N51zOXQghLlfd3ih1uT6LyXSG3Z1ednd6WVblZGNTyYwqkA6HZr6esb7YQWNpwRmb0DeVFXByODR23RdJ8FzrKFuby86YvF5utNZsPzlCjdvOgpKCfIcjxDmRpHEeW1nj4ttvuQqAN3/vOU7kpuEJcSXrHIlw138+C8DnXr1SigcIIQRgMipS6QxDoTixVJodrSM81zrKwtJCtiwsPad+jYPBOOUzTBprPY6zVqwusJqIxNNAtrXEgR4/1y8uw2K6ck5D0xnN0yeGWVxZRLX7ypqKKy4PV85f6yXqthWVfOKOZQC85KtPMRSM5zkiIfLHG05w/ZceB+ADNy3kzzcuyHNEQggxP1hNBuKpDLVuO4VWExsWeNi6qPS8WlZE4qlZHwF0WI0c7vXTMRJha3PphH6Ol7tkOsNTJ4ZYU+umdJoqskLMd5I0XgLefX0Tr99QC8DVn3tk0roAIa4EsWSadZ95GMi2p/nI7UvzHJEQQswfVpORWDJNudNGrccx4zWJU8rlc/pcquGcRTqjOdIX5JrG4iumOipkj11Pnxji6obiK6LnpLh8SdJ4ifji69awtbkUgDX/8hDBmCSO4soRT6XHejGuqHby9Teuy3NEQggxv5waabxQqXQGYy6pG1+R9XxprdnV4cXjMF9x68/D8RTbTg6f8/RgIeYjSRovIT9+10bW1bsBWPXph4gkUvkNSIg5EE+lWfKP2YSxtNDKH//6ujxHJIQQ84/DYiQcv/DzgpFwgpLC2almmslotreOUOmy0VxehH2WYrwU+CNJnm/LFvuZSfEhIeY7SRovMb9+/7UszfVeWv7JB4kl03mOSIiLZ3zCWFJgGWtFI4QQYqKyIiuDs1D3oMcXnVCoRevzm6Kayq3jW1JRRE3u8ZZVFXG4L3DBMc53w6E4e7t9V1yxH3F5k9/kS9CfPnQ99blKZUv/6U8yVVVclk5PGHf900vyHJEQQsxfSikMKltB9ULEEmkcluxUSrvFSPQ8PpyOp9I8fWKY9Qs8lIwr/OKwmEikMmMxnm9COp91jUY4PhDkuius2I+4/EnSeIl66u9vorE02+Nn1acfYjgkVVXF5SMUT0nCKIQQ52hBiYOO0ch575/JaMYvY3RYjEQS55Y0huMpnm0ZZlNTCU7b5MIvSyqLONofpG04zPaTI5dV4nh8IMhwKM7mphIMkjCKy0xekkalVLFS6mGl1Incd88U29yklNo77iumlHpV7r4fKKXaxt23dq5fw3zw+IdvZGNjMQAbPvsIXRdwoBBivhgMxFj5qQcBqHHbJWEUQogZqnLZ6PfHznv/odDE/owOi3Gsv+JM+CNJnm/PruOzW6Zex+ewGHnq+BDpdIYtzaWXTSXVvV0+tIZ19Z7L5jUJMV6+Rho/BjyqtV4EPJq7PoHW+nGt9Vqt9VrgZiACPDRuk4+cul9rvXcOYp6X7vvLzdy1thqA6774OEf7L/+1AuLy1TIY5Jp/fRSALQtLePZjN+c5IiGEuHScmqKaPM8pqt3eKDVux9j1kgIrQzOcyTQYjLGv28f1i6Zex6e15khfgL2dPm5ZVo71MikOk8lotp8coaTAwpJczQkhLkf5ShrvAn6Yu/xD4FVn2f51wANaaxlKm8J/3L2Od1/XCMBL//1pHjs6kOeIhDh3z7eNcutXngLgTRvr+em7N+U5IiGEuPQ0lhbQMRI+r33jyfSEEUK7xTijgnvd3ggnB8Nct2jqdXz+SJInjg9RZDOxpbmUxRVFtA2fX4zzSSqd4emWYZrLC6krdpx9ByEuYflKGiu01n25y/1AxVm2vxu497TbPqeU2q+U+qpSyjrVTgBKqfcopXYqpXYODQ1dQMjz2ydevpxPvmI5AO/4wU6+8diJPEckxMzd+3wnr//WdgA++tKl/OurV+U5IiGEuDRVOK10jUaJnuNaxHRGTzmt0mQ488hly2CIwWCcTU3Fk/bPZDR7u3wcH8wWhqn1ZBMrpRRuhxlvOHFOMc4nsWSap04Msb7eTVnRtKehQlw2LlrSqJR6RCl1cIqvu8Zvp7MroKddBa2UqgJWAQ+Ou/njwFLgaqAY+Oh0+2utv6213qC13lBWVnYhL2nee8fWRn78zo0A/NtDx3nb95/Pc0RCnN1f3buHj//qAABff+M63nfjwjxHJIQQly6lFJsXlrC9dZhEaubTVAeDMcqdk5Of2mIH3d7olPsc6vUTT6VZf9o6Pq01rUMhnjwxRI3bztUNxZiME085l1Y6OdDjn3F884k/mmT7yRG2LCylaIpiP0Jcji5a0qi1vlVrvXKKr98CA7lk8FRSOHiGh3o98Gut9VhfCa11n86KA/8DXHOxXselZuuiUp76yE0APHl8iIaP/TFbDU2IeSaT0Sz5xwf4/b5eAP70oet45ZrqPEclhBCXPpvZyKamEp49OUx6hucAvb7oWD/F8SqdNvr8E5NGrTW7OrxYTUZWVLvGbo+n0uzt8vFMyzBmo4EbF5dNOwpnMRmoK3ZwYiB4Dq8s/wYDMfZ1ZXsw2i6TdZlCzES+pqf+Dnhb7vLbgN+eYds3ctrU1HEJpyK7HvLg7Id46aovcXDon28fu970D/dfUDU1IWabP5Kk6R/uJ577FHz/p29jaaUzz1EJIcTlw2Exsb7ewzMtwzP68DiezEyZBBkNCrPRwEiuIE46o3m2ZYQql43m8kIAfJEE20+OsKfTR2NJAdctKqOu2HHWKqKNpQUMBuOE4qnzeIVzr304TNvw9Gs3hbic5StpvAd4iVLqBHBr7jpKqQ1Kqe+e2kgp1QDUAU+etv9PlFIHgANAKfDZuQj6UlJgNdH2+TuoctkA2PT5R/nTwb6z7CXExffMiWHW/Eu2ELLDYqTt83dM2ctLCCHEhXHZzaysdvLkiSH8keS0252tV+JV9R72d/sJxVM8dXyIlTVOqlw2ukYjPHV8iI6RCOsXuNnUVILLcW7/z69uKGZn++i879d4uDdAMJZiY1OJtNQQVyQ13/9IZ9OGDRv0zp078x3GnPv3R47z749kC+O8ck01X3/jujxHJK5UH/3Ffu7b2QVkK6ReqQVvlFK7tNYb8h2HEPl0pR6T8yGWTHOsP4g/mqTWY6ehpGBC8/mhYJzRcOKMLSMGAzF+sK2dl62sIhhPkslAjcdOQ8nZRxTPptcXZTScYGWN6+wbzzGtNbs7vbjslrGRVSEuV2c6PzHNdTBi7n3o1sXcsLiMV//XNn6/r5ff7+vl0D/fToFVfvxibsSSaZb+05/Grv/03RvZsrA0jxEJIcSVw2Y2sqbOjdaaHl+UbSdHsFsMNJQUYDEZaB8Os7hickIUiqey7TSGQnSORFld66LbF+HWpRWYp+jFeL6q3Xa6vVF8kQRuh2XWHvdCZTKa7a0jNJYWUD3Fek8hriSSNVwh1tV7OPjPt7PyU9kitCs+9SDffesGbl1+tm4nQlyYF9pH+bNvbh+7vv/Tt8l0VCGEyAOlFLUeB7UeB+F4im5vlGQ6w+E+PxmtGb/0UWtNgdVEJqMpLbByx8oqlFKMhhNsax2h1mOnqbRg1qZqXrXAM6OekHMlkcrw7Mlh1ta68RTMn0RWiHyRpPEKUmg10X7Py/nI/+3j/3Z1864f7WRdvZtfvW+LzM8Xs05rzdv/5wWePJ7tj3rz0nK+//ar8xyVEEIIyNY+ODUd9dRavfGS6Qx7u3w4LEbWLfCM3V5cYOGGxWW0D4fZ1+1nbZ17VuIxGtS8mQEVSaTY0TrCxsaSeROTEPkmfwlXoC/92RresnkBd37j2Wyls4/fz2N/dwNNZTJXX8yO9uEwN/7bE2PXf/KujVzbLNNRhRBiPtKntcs+ORSixxtlbb172pkhDaUFcxHanPOGE+zt9rG1uQzLLE7BFeJSJ38NV6jVtW5aPvcySnJTLm7+8pP81b178hyVuBx89g+HxxLGIquJ4599mSSMQggxjxmU4uRQiNahEE8eH8KgFNcvLrvilhL0+aMc6g1wwyJJGIU4nYw0XsFMRgO7/ukl/HpPN39z376xIjn3//V1LK+Wnnni3LQMhrj1Ky92x7nnNau4+5r6PEYkhBBiJtbWufFHk2S0ZsvCEszGKy9hahnMVpe9tllaaggxFUkaBa9eV8vLVlax8V8fxR9NcsfXnmZzUwk/edfGCSW5hZiK1pq3/c8LPJVbuwhS7EYIIS4lNrMRm9mY7zDyQmvN/m4/VrOBqxYU5zscIeatK++jJDElm9nIvk/dxnfemm3Nsr11hKZ/uJ/f7evNc2RiPnvq+BCNH79/LGH82hvX0X7PyyVhFEIIMe+daqlRXGBhaaXMsBLiTCRpFBO8ZHkFLZ97GStrsv88//rePTR87I90eyN5jkzMJwOBGA0f+yNv/f7zADSXF3Licy/jzjXVeY5MCCGEOLtEKsNTJ4ZYUlFEXbEj3+EIMe/J9FQxiclo4A9/dR2tQyFu/nJ2jdrWLzzO1Q0e7n33JkxX4FoHkZVKZ3jTd5/j+bbRsdt+98FrWV3rzl9QQgghxDkIx1M81yYtNYQ4F3L2L6bVVFZI+z0v5wuvXQXAC+1emj/xAJ/+3SG01mfZW1xuvv7oCZo/8cBYwvjpVy6n/Z6XS8IohBDikjESivNC+yhbm8skYRTiHMhfizirN1xdz59dVcd7f7yLhw4P8INt7fxgWzv/+PJlvOu6pnyHJy6ynzzXwSd+fXDs+o1Lyvje267GKEWShBBCXEK6RiN0eSNcv6hMCv0JcY4kaRQzYjAovv3WDUQSKV71n89yfCDEZ/94hM/+8Qhfef0aXrO+Nt8hiln2u329/PW43p0lBRYe+dsb8OR6ewohhBCXiqP9AeLJDJubpKWGEOdDkkZxThwWEw/9zQ0MBeNs/cJjxFMZ/vbn+/jbn+/jk69Yzju2NuY7RHGBfrmrm7/7v31j100GxTMfvZlKly2PUQkhhBDnTmvN7k4vLruZpXXufIcjxCVLkkZxXsqKrBz77MvoHIlw85efIJXR/MsfDvMvfzjMB25ayIdvWyKf5F1CtNZ85eHjfP2xlgm3P/HhG2koLchTVEKIfFNKFQP3AQ1AO/B6rbV3iu3qge8CdYAG7tBat89ZoEJMIZ3RbD85wsLyAqpc9nyHI8QlTV1JBU02bNigd+7cme8wLkuDwRiv+NozDAbjY7dtbS7lv9+8niLp2TdvxZJp/u7n+/jjgb6x2wqtJh74f9dJCfKLSCm1S2u9Id9xCHE2SqkvAqNa63uUUh8DPFrrj06x3RPA57TWDyulCoGM1vqMvZrkmCwupngqzbaWEdbVu3E7ZFmFEDNxpvMTGWkUs6K8yMbzn7iVQCzJn3/nOQ70+HmmZZhVn34IgF+/fwvr6j15jlKccqDbz6v+61nSmRc/NFpV4+LH79qIyy5JvhBizF3AjbnLPwSeACYkjUqp5YBJa/0wgNY6NIfxCTFJIJZkV7uXTU0l2C3GfIcjxGVBkkYxq5w2M7//q61kMpovPniMbz55EoBX/9c2AN6+pYGP37EUq0n+ic+1dEbzlYeP8Z+Pn5xw+xs21PHZV6/ELP03hRCTVWitT01F6AcqpthmMeBTSv0KaAQeAT6mtU6fvqFS6j3AewDq6+svTsTiijYYjHGkL8h1i0qlr7QQs0imp4qLblvLMG/67nOTbv/mm9fz0pVVeYjoyvLokQHe+cPJv/c/fMc13LC4LA8RCZmeKuYTpdQjQOUUd30C+KHW2j1uW6/WesK0EaXU64DvAeuATrJrIO/XWn/vTM8rx2Qx21oGg3gjSTYs8EhdBSHOg0xPFXm1pbmU9nteTjie4h9/c5Bf7+kB4L0/3g1AXbGdf3/DOq5aINNXZ8vR/gDv/d9dtI9MXFJ045Iy/uPudTIFVQgxRmt963T3KaUGlFJVWus+pVQVMDjFZt3AXq11a26f3wCbyCaSQlx0Wmt2dnhx281c3VCc73CEuCxJ0ijmTIHVxFffsJavvmEtR/sDvON/XqDXH6NrNMpr/zs7fbW4wMJ/3L2W6xbJCNi5erZlmI/83z56/bEJt1c4rXznrRtYXevOT2BCiEvZ74C3Affkvv92im1eANxKqTKt9RBwMyBDiGJOxFNptp8cYXm1k/IiaQ0lxMUiSaPIi6WVTrZ9/BYAHjk8wIfu20sonmI0nOAt33t+bLv/d8si3nN9EwVW+VU9XTyV5ic7OvmXPxye8v5vvGkdr1hdPcdRCSEuM/cAP1dKvRPoAF4PoJTaALxXa/0urXVaKfVh4FGVnRO4C/hO3iIWVwxfJMGeTp8UvBFiDsiaRjGvbD85wofu28NAID7pvoVlBXzk9iXctrwSg+HKW6ugteZPB/v50oPHaB0OT7q/2mXji69bw9ZFpXmITpwLWdMohByTxYVpHw7T64+ysbEE4xV4TiDExSBrGsUlY/PCEp77h+zymj5/lK88dJz/29UNwMmh8Ng6SACnzcRf3rCQN29acFmu0fOGE/z0+U7+59l2hkOTk2iAl66o5KMvW0pjacEcRyeEEELMPa01e7t8WEwGtiyUD0mFmCt5GWlUSv0Z8GlgGXCN1nrKjxqVUi8F/gMwAt/VWt+Tu70R+BlQQnYazFu01omzPa98qnnp0lrz9IlhvvboCXZ2eKfdrsZt57Xra3jN+loaLqFE6uRQiN/v6+UP+/toGZy+xdmaOjd/f/sSrm2WA+WlTEYahZBjsjh3yXSGHa0jLCwrpNptz3c4Qlx25uNI40HgNcC3pttAKWUE/hN4CdnKbC8opX6ntT4MfAH4qtb6Z0qpbwLvBP774oct8kUpxfWLy7h+XIuIlsEg33mqjft2do3d1uOL8rXHWvjaYy0T9i+ymbght/+mxhLqiu1zWo5ba03bcJjtrSNsPznCjtYRhkNn/ZyDN15Tx9u3NLKksmgOohRCCCHmp2AsyQvto1zdUEyR7fKbXSTEfJeXpFFrfQQ420n7NUDLuBLePwPuUkodIVuZ7U257X5IdtRSksYrTHN5EV943Wq+8LrVY7cd7Q/w6909/HJ394SkLBhL8Yf9ffxhf99UDzXGaTNR4bRR4bRRXmSlrMiK3WLEZFAYDCr7Pfd7G4qn8IYTeCNJvJEE3kiCwUCcweDUU0nPpMJp5ZWrq3nlmmpW17qkv5QQQgiR0+uLcnIoxPWLyjAZDfkOR4gr0nxe01gDdI273g1sJDsl1ae1To27vWaOYxPz1NJKJx+/w8nH71g24fbBQIynTgzz1PEhdraPTmpLcUogliIQC3HiDFNEz1eN286mphI2NRWzqamEWs/cjnYKIYQQlxpvOMFgMM7W5lI5ZgqRRxctaVRKPQJUTnHXJ7TWU/V5ulhxvAd4D0B9ff1cPa2YZ8qdNl53VS2vu6p22m0yGY0/mmQgGBsbMRwKxokmUqS1JpXRZDLZ7wCFVhMehwVPgRm3w4LHYaGsyEql0yaV3IQQQohZ4Cmw4Cmw5DsMIa54Fy1p1FrfeoEP0QPUjbtem7tthGwTYVNutPHU7dPF8W3g25BddH+BMYnLmMGgxg5OS6f6uEMIIYQQQogr0HyeGP4CsEgp1aiUsgB3A7/T2XKvjwOvy233NmDORi6FEEIIIYQQ4kqSl6RRKfVqpVQ3sBn4o1Lqwdzt1Uqp+wFyo4gfBB4EjgA/11ofyj3ER4G/VUq1kF3j+L25fg1CCCGEEEIIcSXIV/XUXwO/nuL2XuCOcdfvB+6fYrtWstVVhRBCCCGEEEJcRPN5eqoQQgghhBBCiDyTpFEIIYQQQgghxLQkaRRCCCGEEEIIMS1JGoUQQgghhBBCTEuSRiGEEEIIIYQQ05KkUQghhBBCCCHEtCRpFEIIIYQQQggxLUkahRBCCCGEEEJMS2mt8x3DnFFKDQEd57hbKTB8EcKRGC7NGGB+xCExXNoxLNBal12MYIS4VMzwmDwf/sbPxaUWL0jMc+FSixck5rkwH+Od9vzkikoaz4dSaqfWeoPEIDHMpzgkBolBiCvBpfb3danFCxLzXLjU4gWJeS5cavHK9FQhhBBCCCGEENOSpFEIIYQQQgghxLQkaTy7b+c7ACSGU+ZDDDA/4pAYsiQGIS5vl9rf16UWL0jMc+FSixck5rlwScUraxqFEEIIIYQQQkxLRhqFEEIIIYQQQkxLkkYhhBBCCCGEENOSpBFQSv2ZUuqQUiqjlJq29K1S6qVKqWNKqRal1MfG3d6olHoud/t9SinLecRQrJR6WCl1IvfdM8U2Nyml9o77iimlXpW77wdKqbZx9629GDHktkuPe57fjbt9rt6HtUqp7bmf2X6l1BvG3Xfe78N0P99x91tzr6sl9zobxt338dztx5RSt5/r6z6HGP5WKXU497ofVUotGHfflD+XixDD25VSQ+Oe613j7ntb7md3Qin1tosYw1fHPf9xpZRv3H2z9T58Xyk1qJQ6OM39Sin1tVyM+5VS68fdNyvvgxBXmnM4DtUrpR5SSh3J/U9smONQT8Uxo3hz2zqVUt1KqW/MZYxTxHFBx9k5jvW8j8v5cCHH8Hw5W8zjtnutUkqrM5wnz4WZxKuUen3ufT6klPrpXMc4RTxn+72oV0o9rpTak/vduCMfcZ6V1vqK/wKWAUuAJ4AN02xjBE4CTYAF2Acsz933c+Du3OVvAu87jxi+CHwsd/ljwBfOsn0xMAo4ctd/ALzuAt+HGcUAhKa5fU7eB2AxsCh3uRroA9wX8j6c6ec7bpv3A9/MXb4buC93eXlueyvQmHsc40WK4aZxP/P3nYrhTD+XixDD24FvTPM72Zr77sld9lyMGE7b/q+A78/m+5B7nOuB9cDBae6/A3gAUMAm4LnZfB/kS76uxK9zOA49Abwkd7nw1P/F+Rpv7v7/AH461f/P+RbzmY6zcxjneR+X8/S+XtAxfL7GnNuuCHgK2ME058nzJV5gEbDn1HEXKJ/v7zHZgjjvy11eDrTnM+bpvmSkEdBaH9FaHzvLZtcALVrrVq11AvgZcJdSSgE3A7/IbfdD4FXnEcZduX1n+hivAx7QWkfO47lmK4Yxc/k+aK2Pa61P5C73AoNA2Xk813hT/nzPENsvgFtyr/su4Gda67jWug1oyT3erMegtX583M98B1B7Hs9zQTGcwe3Aw1rrUa21F3gYeOkcxPBG4N7zeJ4z0lo/RfaDmencBfxIZ+0A3EqpKmbvfRDiSnTWY4BSajlg0lo/DKC1Ds3ysfBczOi4qZS6CqgAHpqbsM4oX8fZc3Uhx+V8mA/H8HM10+PtZ4AvALG5DG4KM4n33cB/5o6/aK0H5zjG080kZg04c5ddQO8cxjdjkjTOXA3QNe56d+62EsCntU6ddvu5qtBa9+Uu95M9uJzJ3Uw+Uf5cblj7q0op60WMwaaU2qmU2qFy02PJ0/uglLqG7Cc3J8fdfD7vw3Q/3ym3yb1OP9nXPZN9ZyuG8d5JdqTrlKl+Lhcrhtfm3uNfKKXqznHf2YqB3NSeRuCxcTfPxvswE9PFOVvvgxBXopkcAxYDPqXUr3LTub6klDLOXYgTnDVepZQB+DLw4bkM7Axm4zg7Fy7kuJwPF3oMz4ezxpxbelGntf7jXAY2jZm8x4uBxUqpZ3PnAfn+0HYmMX8aeLNSqhu4n+wMqnnHlO8A5opS6hGgcoq7PqG1/m2+Yxh/RWutlVLT9kLJjWasAh4cd/PHyf7zt5Ad5v4o8C8XKYYFWusepVQT8JhS6gDZf9QzMsvvw/8Cb9NaZ3I3z+h9uNQppd4MbABuGHfzpJ+L1vpiHOR/D9yrtY4rpf6S7Ke8N1+E55mJu4FfaK3T426bq/dBCHEeZuEYYAKuA9YBncB9ZKfNf292I82ahXjfD9yvte6eq0Gwi3ycFRdommP4vJP7wOMrZP++LhUmslNUbyQ7kvuUUmqV1tqXz6DO4o3AD7TWX1ZKbQb+Vym1cr79zV0xSaPW+tYLfIgeoG7c9drcbSNkp6WZcp9ynbr9nGJQSg0opaq01n25f9JnGk5/PfBrrXVy3GOf+tQwrpT6H6b5RHM2YtBa9+S+tyqlniB74P4lc/g+KKWcwB/JJv07xj32jN6HKUz3851qm26llInsFIKRGe47WzGglLqV7IH/Bq11/NTt0/xczjVZOmsMWuuRcVe/S3Z9zKl9bzxt3yfO8flnFMM4dwMfOC2+2XgfZmK6OGfrfRDisjQLx4BuYK/WujW3z2/Iriu+KEnjLMS7GbhOKfV+susvLUqpkNZ62qIjF+piHmfn0IUcl/Phgo7heXK2mIuAlcATuQ88KoHfKaXu1FrvnLMoXzST97ibbI2BJNCmlDpONol8YW5CnGQmMb+T3DIWrfV2pZQNKOXMucCck+mpM/cCsEhlK4RayJ6s/k5rrYHHya4xBHgbcD4jl7/L7TuTx5i0hiv3j//U2sJXAVNWfLzQGJRSnlNTPpVSpcC1wOG5fB9y7/+vya4n+8Vp953v+zDlz/cMsb0OeCz3un8H3K2yVdwayf5zen6Gz3tOMSil1gHfAu4cP09/up/LRYqhatzVO4EjucsPArflYvEAtzFxNHzWYsjFsZRsoZnt426brfdhJn4HvFVlbQL8uQ8tZut9EOJKNJNj4QtkP6Q8tcbuZi7e3/nZnDVerfWfa63rtdYNZD/I/NHFTBhn4IKOs3PoQo7L+XDex/A8OmPMWmu/1rpUa92Q+/3dQTb2fCSMMLPfid+Q++A2dx6wmGxBunyZScydwC0ASqllgA0YmtMoZ0LPg2o8+f4CXk32k4k4MAA8mLu9muyUklPb3QEcJztq8YlxtzeRTRJagP8DrOcRQwnwKHACeAQozt2+AfjuuO0ayH5CYTht/8eAA2STpB8DhRcjBmBL7nn25b6/c67fB+DNQBLYO+5r7YW+D1P9fMlObb0zd9mWe10tudfZNG7fT+T2Owa87AJ+F88WwyO539FTr/t3Z/u5XIQYPg8cyj3X48DScfu+I/f+tAB/cbFiyF3/NHDPafvN5vtwL9mKgUmy/x/eCbwXeG/ufgX8Zy7GA4yrKDdb74N8ydeV9jWTY0Du+kuA/bm/vR8Alvkc77jt307+q6de0HF2jmM97+Nynt7b8zqGz+eYT9v2CfJYPXWG77EiO6X2cO7/w93z/T0mWzH1WbLnLnuB2/Id81RfKhesEEIIIYQQQggxiUxPFUIIIYQQQggxLUkahRBCCCGEEEJMS5JGIYQQQgghhBDTkqRRCCGEEEIIIcS0JGkUQgghhBBCCDEtSRrFFUsplVZK7VVKHVJK7VNK/Z1SypC7b4NS6msX8Nh/lnvcjFJqw+xFLYQQQoiLQc4LhJieKd8BCJFHUa31WgClVDnwU8AJfEpnG9deSPPag8BryDbxFUIIIcT8J+cFQkxDRhqFALTWg8B7gA+qrBuVUn8AUEp9Win1Q6XU00qpDqXUa5RSX1RKHVBK/UkpZZ7i8Y5orY/N9esQQgghxIWT8wIhJpKkUYgcrXUrYATKp7h7IXAzcCfwY+BxrfUqIAq8fM6CFEIIIcSckPMCIV4kSaMQM/OA1joJHCB7APlT7vYDQEO+ghJCCCFEXsh5gbiiSNIoRI5SqglIA4NT3B0H0FpngKTWWuduzyBrg4UQQojLjpwXCPEiSRqFAJRSZcA3gW+M+8cvhBBCiCuQnBcIMZF8EiKuZHal1F7ADKSA/wW+MhsPrJR6NfB1oAz4o1Jqr9b69tl4bCGEEEJcFHJeIMQ0lHx4IoQQQgghhBBiOjI9VQghhBBCCCHEtCRpFEIIIYQQQggxLUkahRBCCCGEEEJMS5JGIYQQQgghhBDTkqRRCCGEEEIIIcS0JGkUQgghhBBCCDEtSRqFEEIIIYQQQkzr/wM0d88qDXq6JwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -500,7 +500,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -614,7 +614,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -689,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -720,22 +720,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f = plt.figure(figsize=(15, 5))\n", "ax1 = f.add_subplot(1, 2, 1, projection='3d')\n", @@ -785,22 +772,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAFgCAYAAABNIolGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9eZhcR3X3/z19e51Fs2hGi7V4NxhD2ElIICEJCSQhOG9eIOzkl+2HE0jyQiAJIWBCHAiQF7MHbGKIDRgDjo13Yxthy5u8STJabFmypNn3nul9uV3vH3XrdnXPvXWrZ3qmu6X6PA8P1syd29V3rfOt7zmHGGMwGAwGg8FgMBgMBoPBYGhnQq0egMFgMBgMBoPBYDAYDAZDEEbAMBgMBoPBYDAYDAaDwdD2GAHDYDAYDAaDwWAwGAwGQ9tjBAyDwWAwGAwGg8FgMBgMbY8RMAwGg8FgMBgMBoPBYDC0PUbAMBgMBoPBYDAYDAaDwdD2GAHDYGgRRPQRIrqy2dtq7IsR0Xk+v9tFRH/WjM9Za4joNUQ02upx1ENEB4joNa0eh8FgMBhOL4joLOcdH271WGSI6DYiek+rx9EJnCpzNINhLTEChsHQBIjoj4noSSLKEtEkEX2NiPpVf8MY+zfGmNaLqJFt1wsiOk5Er23Svtpy0rUSGGMXMcZ2tXocBoPBYFgZK32/NTvAVAWznQRj7HcYY99u9TjWeq7hzAV3r8W+mw0RRYnoY0T0FBFliGjMEZp+W9rmOBHliChNRFNEdBUR9Ti/20VEeed34n+vlP6WiOgEEe1vxfcznNoYAcNgWCVE9EEA/w7gQwD6APwSgDMB/ISIoj5/0/GBusFgMBgMBsOpxGk0P/shgIsBvBvAAICzAXwBwO/Vbff7jLEeAC8B8HIAH5V+9z7GWI/0vwel3/0GgEEAzyWiF6/VlzCcnhgBw2BYBUS0AcAnALyfMXY7Y6zEGDsO4C3gIsY7ne0uJaIfEtE1RLQE4I+dn10j7evdjlo9R0T/LK8AydtKKwjvIaKTRDRLRP8k7ecVRPQgESWJaIKIvuwnpAR8t3OJ6B5nPLNE9B3hKiGiqwHsBHCTo7p/2Pn5LxHRA85n75NTKRy1/pNEdD8RpYjoTiIacn59r/P/yXoVX/r7BBF9i4gWiOgg+ItU/O5DRPSjuu2/RESXa3w2iOgHjnNmkYjuJaKLpN99i4i+6qxMpJ19bCGiy52xHJZfznXnzSKe/nPU+dzHiGiHszLxeSKadj5zPxE9v9FzZDAYDIb1g4gGiOhmIppxnv83E9F253eXAXg1gC8774ovOz9/LhH9hIjmia92v0Xa37eI6CtEdIvzjniYiM51fifei/uc/f2Rx3gsIvqc844+Bin4JKI3E9Fjddt/kIhuCPps5/dfIKIRIlpy3l2vln53qfPevMb52yeJ6AIi+kfnvTZCtSv5Nc4UIvpzIjrk/O1BInqJ8/O/J+4ESDnH6jd9zkPM+d4niTsD/pOIEtI+HiJHiCCiS4indsbhMdcg7pq433knzwO4lBTzH2efO4joeuc6mCM+z7oQwH8CeKWz72TQWJ3ff4j4XG2ciP7E6/vWcS4R7XHmDjcS0aCzn1uI6P11x2k/Ef2Bx/F7LYDfAnAxY+xhxljR+d/tjLG/8fpQxtgYgNsA6M5V3gPgegC3O/9tMDQNI2AYDKvjlwHEwR/SLoyxNPiD/rekH18Mrnj3A/iOvD0RPQ/AVwG8A8BWcCfHtoDPfhWA5wD4TQAfc16eAGAD+D8AhgC80vn9Xzb4vQCAAHwKwBkALgSwA8Clzvd7F4CTcJR5xthniGgbgFsA/Cu46v53AH5ERMPSPt8O4P8DsAlA1NkGAH7V+f9+DxVf8HEA5zr/ex1qX4jXAHg9VQWWMIA/AnC1xmcD/Fyd7/zucdSdH3BB6qPgx7QA4EFnuyHwc/p/PcYLAB8A8DYAvwtgA4A/AZAF8NvOd74A/Hr4IwBzPvswGAwGQ3sQAnAV+ALFTgA5AF8GAMbYPwG4D9VV6fcRUTeAnwD4Lvj75W0AvkqSSO787BPgq+DPALjM2Z94L77Q2d/3Pcbz5wDeAODFAF4G4E3S734M4GxpbgDwRRX5vej52Q6PAHgR+Pv8uwB+4IgAgt939jUA4AkAdzjHZxuAfwHwdY/xgojeDD6XeDf4e/GNAOaI6DkA3gfg5YyxXvD3/HGvfYC7Xi9wxnee85kfc373WQBFAB8lovMB/BuAdzLG8vCfa/wigGPg5+gyKOY/RGQBuBnACQBnOZ99LWPsEID3AnjQ2bcQPHzHSkSvB5+L/Bb4HEQnbend4HOJMwCUAXzR+fm34SyaOft+ofNZt3rs47UAHmaMadcRI6Id4HOZJzS27QHwh+Bzqe8AeBudPs4WwzpgBAyDYXUMAZhljJU9fjfh/F7wIGPsBsZYhTGWq9v2TQBuYoztZowVwV9uLOCzP8EYyzHG9gHYB+CFAMAYe4wx9hBjrOy4Qb4O4Nca/WKMsWcYYz9hjBUYYzPgQbpqP+8EcCtj7FbnO/4EwKPgLzzBVYyxp53vfx34C12XtwC4jDE2zxgbQfWlDcbYBPjKypudH70e/LzIq0++n80Y+y/GWIoxVgCfpLyQiPqkv/0f57jmAfwPgDxj7L8ZYzaA74NPHr34MwAfZYw9xTj7GGNzAEoAegE8FwAxxg4538FgMBgMbQpjbI4x9iPGWJYxlgIPdlXvxTcAOM4Yu8p5Jz8O4EeoFRquZ4ztceYR30Hj78XLGWMjjLF58KBbjLUA/n4STtCLwAPum3U+mzF2jfN9y4yx/wAQA180EdzHGLvD+dsfABgG8GnGWAnAtQDOIu9aYH8G4DOMsUec9+IzjLET4IsvMQDPI6IIY+w4Y+xo/R8TEYELN//HmQ+kwEWKtzrjroAH+X8NLuJ8hjEWFHSPM8a+5HzXXMD85xXg4sGHGGMZxlieMeZZ9yJorODn7yrG2M8ZYxk4IkkAV0vb/zOAtziiyo0AzndEGwB4F4DvO3PKeoYATErjHCTunF0konzdtjc4bpLdAH7mjF/wRefvkkT0uPTzNwFIA7gb/Bx0Afgdje9mMGhhBAyDYXXMAhjyUZa3Or8XjCj2c4b8e8ZYFsEr8pPSf2cBiMJKFxC3tU4ST1f5N9QKKVoQ0SYiutaxcy6BuxxU+zkTwJull1kS3CWyNWjMmtQcI/DVDxl59aF+lcn3s4lbcD9NPM1jCdUVH/m7Tkn/nfP4t9/32AFg2QSMMXYP+KrdVwBMEdE3iKcjGQwGg6FNIaIuIvo68XTPJXDhvN8JIL04E8Av1r0X3wFgi7TNWr8X3+4E0u8CcJ0jbAR+NvF0k0NOUJsEd4aq3ouzjqgv/g2f7+L3XnwGwN+CB/HTzvzjDI+/HwYPiB+Tjuntzs/Fvo4D+Cm4YPMVj33UUzM/C5j/7ABwwmfhqtGxBp2/oLGeABABMOSc1+sAvJOIQuDumvp5kGAO0tzMEVf6AbwUXESS+QPGWD9j7EzG2F/WLcD9tfO7fsbYS6SfvwdcPLGd7f8HJo3E0ESMgGEwrI4HwVMK/lD+oWMb/R1w9VmgclRMANgu/X0CwMYVjulrAA4DOJ8xtgHAR8DtkI3yKfAx/4Kzn3fW7af++4yArwz0S//rZox9WuOzgtwmAD9GO6R/76z7/Q0AfoF4LYk3YHkaiB9vB0/veS34BO0s5+crOWb1jICnvCyDMfZFxthLAVwEbi/9UBM+z2AwGAxrxwfBXQi/6LwXRUqCeF94vRd/Vvde7GGMXdKk8Sjfi4yxh8DTKV4N/q7zC2hrIF7v4u/BHQIDTnC7iLV/L36XMfYqcOGHgadf1DMLLpBcJB3TPsYLTYrx/y54Cu3d4Ckl7kf4jKn+56r5zwiAnT4LV/X7CRpr0LzGi/rtS6guln0bXCD7TQBZ5p2OC/Dj8nJy6rc0EyI6E9yt8sfOQtokgD8A8AYiGmj25xlOT4yAYTCsAsbYInj+6JeI6PVEFCGis8DtlKPQnCyA11H4fSL6ZeIFNz+BlU8UegEsAUgT0XMBrHSi1AtuAUw69S3qA+wpAOdI/74G/Du8znE1xInoNZovyBkAlbr91XMdgH8kXkRtO4CaYlVOescPwXN19zDGTmp8LsC/ZwF8RaILtfbI1XIlgE8S0fnE+QUi2khELyeiXySiCIAMgDy4fdZgMBgM7UHEeY+J/4XB3xc58PfiIHhtJpn69+LNAC4gonc584OI8/y/EHrU76+e6wD8NRFtd4LDf/DY5r/BHX9lv1QHD3rB6yvMAAgT0cfA61U0gysB/B0RvdR5L55HRGcS0XOI6DeIKAb+TszB473opIhcAeDzRLQJAIhoGxG9zvnvIQDfBE9VeQ/4vESksurMNQD1/GcPuPDwaSLqdq6NX3F+NwVguzOPCxwr+Pn7YyJ6HhF1Yfn15MU7pe3/BcAPhfPFESwqAP4DivknY+xOcIfKDc5cJOrMR35J4/ODeDeAg+BC34uc/z0H/Ni8VfF3BoM2RsAwGFYJY+wz4C6Hz4ELBw+DK/S/WWfVVO3jAHhAfi34izEFYBo8sG6UvwNfaUmBvzi9Cn/p8AnwtlmL4MU5r6/7/afAi2QliejvGK9LcTH4sZgBPwYfgsZzxkmZuQzA/c7+vF6inwC3Sz4L4E54v5y/DeAFPr/z47+d/Y6Bv3QfauBvg/i/4BOUO8GvjW8CSIBPBK8AsOB89hz49WMwGAyG9uBW8CBa/O9SAJeDP8Nnwd8Vt9f9zRcAvIl4h5IvOjUPfhs8cBsHT9n4dyy36ftxKYBvO+/Ft3j8/grw4pn7wAtL17+nAf4+fD4aey/eAV7c+mnwd1Qe6jRYbRhjPwB/338XfJ5yA3ih0BiAT4Mf20nwgpof8dnN34MXHX3ISfG4C9X6HN8AcCPj9bjmAPwpgCuJaKPmXANQzH8cseD3wQtyngRfrBIdYu4BcADAJBEJV4TvWBljt4FfU/c429zjf+RcrgbwLfBjFAev9SHz3+DzoGug5g/BBbZrACTB51bvAK8hthreDeArjLFJ6X8T4PXYTBqJoSkQYzrObYPBsJ4Qr+CcBE8DebbV4+kUiGgnePrMFsbYUqvHYzAYDAZDK3FSUqcBvIQxdqTV4zGsLUT0bgB/4aTiGAynJMaBYTC0CUT0+06BsG7w1fgn4d9CzFCHU7TqA+DtzIx4YTAYDAYDTyN9xIgXpz5OWslfgrtQDIZTFtOT12BoHy4GtwYSePvRtzJjkdLCEX2mwK2uq7U/GgwGg8HQ8RDRcfA5xR+0eCiGNcapq3E9eIrKd1s8HINhTTEpJAaDwWAwGAwGg8FgMBjaHpNCYjAYDAaDwWAwGAwGg6HtaasUkqGhIXbWWWe1ehgGg8FgMBg0eOyxx2YZY8OtHkcQZn5hMBgMBkNn4TfHaCsB46yzzsKjjz7a6mEYDAaDwWDQgIhOtHoMOpj5hcFgMBgMnYXfHMOkkBgMBoPBYDAYDAaDwWBoe4yAYTAYDAaDwWAwGAwGg6HtMQKGwWAwGAwGg8FgMBgMhrbHCBgGg8FgMBgMBoPBYDAY2h4jYBgMBoPBYDAYDAaDwWBoe4yAYTAYDAaDwWAwGAwGg6HtMQKGwWAwGAwGg8FgMBgMhrbHCBgGg8FgMBgMBoPBYDAY2h4jYBgMBoPBYDAYDAaDwWBoe4yAYTAYDAaDwWAwGAwGg6HtMQKGwWDoeIp2sdVDMBgMBoPB0OHYFYaSXWn1MDoCxlirh2A4TTEChsFg6GiOJY/hpde8FLvHdrd6KAaDwWAwGDqYv/rO43jd5fea4DyAOw5M4sKP3Y6Hjs21eiiG0xAjYBgMho7mwYkHAQD3nLynxSMxGAwGg8HQqRTKNm4/MIljMxmMLuRaPZy25rsPn0S+VMENT4y1eiiG0xAjYBgMho4mEooAACrMWD4NBoPBYDCsjGMzGfe/J5fyLRxJe8MYwxMnFwAAR2fSLR6N4XTECBgGg6GjKVVKAACb2S0eicGwOowIZzAY1oPjsxn8fGyx1cNoO56eSrn/PZ40Dgw/FrIlLOXLAIDpVKHFozGcjhgBw2AwdDT5Ml8lsStGwDB0LgfmDuDl17wcB+YOtHooBoOhATqtVgJjDO+48mG84Uu7sZAxBbBlnpmuugmS2VILR9LejC5kAQA7B7swvVTouHvA0PkYAcNgMHQ0eZsLGBWY1WtD53LbsdtQrBTx4PiDrR6KwWDQZHQhi1/77C5cftfTrR6KNiPzOYw57oKfjxsXhszB8SXsHOwCAKQL5RaPpn0R9UF+YXsfciUb+ZKZfxnWFyNgGAyGjiZX4i9S00rV0MmEyLyODYZO47N3PIWT81l8/WfHOmYV+omRBfe/R+Y7J03ixFwGlcraHWPGGPaNJvHyswYRDhEyRsDwZcwRMC7cugGAEXvakW/ufhaHJ5daPYw1w8yYDKcdyXwSH3/g45jMTLZ6KA0hUiUMtQgHRsE2eZhB7B7bjW8++c1WD8PgQSwcA2CEOIOhU5hayuOmfeOIhUPIleyOqQVwZKqaJjGf6Ywx73pqGr/22V343iMn1+wzxpI5zKaLeOGOPnTHwiYoVzC6kEVvPIxt/QkAQCpv0m3aiaenUvjkzQfxtm881OqhrBlGwDCcdtw/fj+uP3I9vnf4e60eijbZUhav/O4rccX+K1o9lLZDCBdGwAjmkrsuweWPX95R9UImM5PYM7Gn1cNYc8TqrRDkDAbDcgplG4ttUpvgxr1jqDDgg799AQBgeqkz3kFHplM4Z7gb3VEL85n2OJZBPHEyCQDYfWR2TfZ/18EpvP2KhwEAv3LeEHqMgKFkdCGH7QNd6ImFAXSWA+PaPSfxg0dHWj2MNWXPs/MAeLHVUxUjYBhOO3Jlbn2by821eCT6HF86jjIr49sHv93qobQdIhg3K9f6pEud0/bs0gcvxZ/e+adut5lTlXKFTwBFSpTBYFjOxV++H6/9/M/WNJVAl93PzOGCzT142VmDAIDZdKcIGGmcv6kHgz3RjnFgnJjj7U3n1qDoaKFs4wPX7UW+ZOOjv3chzh3uQU8sbFJIFIwu5LCtP4GeuCNg5DvjWNkVhn+4/kl86If7UbJP3bodByd46kjUCnVMalujGAHDcNqRLvLgLRwKt3gk+mRK/OVt2iwup8z4i9Ok2OizVOicvMj7x+4HwFO/TmVEG+BsOdvikRgM7Um+ZOPwZAozqQKOOwFtEA88M4vP/+Tppk/iS3YFjx6fxy+dsxHDPTz9a6YDBAy7wnByLouzh3rQG4t0zMr58Tn+XExmmy9gPHEyiaV8GZf9rxfgz159DgAgHrWQM4UpPWGMYSyZw/aBhOvASHXIdXRoojr3mVw8deeM4nsW7QoWc6fm4o8RMAynHZly54kBwjVSsk/NB9FqMA6Mxlksdl7l+fn8fKuHsKa4DoyycWAYDF7IosWJOT2h7z1X7cEX7j6CA+PNFW2fnc0gW7Txkp0D2JCIAACWOiBQmFrKo1xh2DGYQHfMQrbYGemEwoGxFpb4B47OIUTAK84edH8WC4dQKHXGsVlvFnMlpAtlbB9IIBG1AHBxsZ1ZzJaw+8ism1oBVDupnGrYFYbDEylscNwxp6qA0TlL0IaG2T22GyeXTuLtF7691UNpK0Sg0Ek2ehHUiFVaQxVxTEztAH06MUjupPt1JRgBw2BQMyMVydRxO5TsCko2d16cmMvi+dv6mjYWUQjz/M096HaCuE4QA0TQtn2gC13RMJIdENws5kpYyJZghQgLmSIYYyCipu3/4PgSzh3uQZ8jRAFcwEh1SFrEelO9hhKIRzpDwPjojT/HTfvGa352qgb2z85mkCvZeOW5m3DP4emOeC6tBOPAOIW55K5L8Kk9n+oop8F6IFbsOylQEGMlNO+lfaogBAzjwFAjW6g7Md2mk+7XlSCu41P9exoMK0UWMHTqTZyQHBuTS8195j09lUKIgHOHexC2QoiFQx1RM2F0gTtXtg8k0BW1kO2AMZ903DYv2NaHcoUh3+TUjmOzaZwz3F3zs3jEavugvFVUr6EuxMM8jGz2OWkmlQrDrsPT7r9/7YJhAJ1VeLQRHjzG6/u9+vwhAJ0hrK4EI2CcBnTayuX+mf340dM/WrP9i2KAndS1IlviL4xmrjqcKghBqpPOZyuQj08nulVO9cBeODBMmpihHTkxl8HfXvsEjs/q1Z5YC2QBYz4dLFifnK+mmUynmvvMe2Y6jZ2DXe4KdKd0rRCr59v6E+iKhjsiuBGpQxdu3QAAyDVRWCjbFZycy+Kc4Z6an8fCIRTL7RuUtxIvB0Yzz0mzOTmfRapQxkd+97n46O9diH+5+CIAQPoUbf1639Mz2NafwPPE/dIB9/hKaJqAQUQWET1BRDc7/z6biB4moiNE9H0iijbrswyNsVjorHz3D+z6AC598NI16zrgphx00Cp0JzowfjbyM7cA41oizqcRMNSIABnorGtf0EoBYzIziRNLJ9b0M8x1bGhn/vWWQ7hh7ziufaR17QdnUgUkIhaGe2PIFIPFAjnHvdnuiCPTKZy3qdf9d1fM6ggHxthCDsO9McQjFrpjltZxbDXCSfPcLfx4Z5s45tGFHMoVhrOHljswCkbA8GR0IYeeWBh9iUhHpJCMLAgHTz/+7NXnYEtfHEDnODBu3DuGXU9NB28IYGQ+i7sPT+N1F21Bt1NgtZn3SzvRTAfG3wA4JP373wF8njF2PoAFAH/axM8yNMBSsXM6DgDAVHYKALCQX1iT/YtArpNWocVYGTqnHdL77nkf3nvXe9f8c2QHxqnaLqoZyPVTOsXNIM4tUHUhtYIP/exDePNNb17TzxCCbbFiUqEM7cWB8UXcfYi/l+Uq/uvNTLqATRtijtshOGAaXcghFg5hW38CWY3tdbErDM/OZnDepuqqfXdUb0ytZjSZxfaBBAAgEbE6YnX2+FwWmzfEMNjN10GbOeZjs9yhfG5dCkksHGrroLyViBaqRAQrRIhaobZOIRmTHCMAEAtbiIZDHdE5ZWIxh7+5di/++KpHtLa/4r5jsIjwF796jltgtRNcViuhKQIGEW0H8HsArnT+TQB+A8APnU2+DeAPmvFZhsZJFVNN3d9EegLvuPUdOLl0sqn7rWetug64K53lzlnpFLbygl3oiJom6ykkyIH5Wrl2TgXkY9MpDgzZjdBK0WXvzF7kyrk1vfdMNx1Du/KJmw6ivyuKl505gOlU696bM6kChnpi2rUbRuaz2DaQQG+8uekdc+kCSjbDNicgAoBE1EKh3P6BwuhCDtsHugAA0XAIRbvS9sL/ibkMztzYja41CMiOzXB3x9lD9SkkxoHhx+hCVQQDgFikvcWesWQOIYLrvACA7mhnOKYePV5dyA0ab9mu4Ob9E3j987dgS198Te6XdqJZDozLAXwYgLjbNwJIMsbE0R4FsM3rD4noL4joUSJ6dGZmpknDMcg0O1i56dhN2D+zHz8++uOm7reeTGltcm070YEh2/9bZTHPlrLaQaQ8Rnnsa4EsYBj7vT+ym6FTrn1ZdGkH10izxWAZcZ+Ya9jQTjw5uog9z87jfb9+Hs7f3FNTh6IZMMa0xYWZVAGbemPo1qw3MZ7MObUempsqMbHIn59nSAERb7vZ3gGvXWEYT+bc4DNqhcAYUK60t4Dx7GwGZ23sWpMVZZEOMdAVqfl5vM2D8lYyJl1DAHfytPOxGlvIYWtfAhGrGvLGwlZH1DgRAhsQXLj4sRMLmM8U8TvP3wIAiIf5/dIJwupKWLWAQURvADDNGHtM/rHHpp5PSMbYNxhjL2OMvWx4eHi1wzmlWalK3uyJv5ho67b0/M6h7+C6p65r+HPWSsAQQVGnrEIDQJlVJ1+tCuT+6OY/0rbRZ8tVu/9anUeBHJib4M8f+X7tlGtfFr9amUIiWMt6QqYGhqEduXn/OKJWCP/7pduxsTuG+UxzU/Xe/V978JrP7tKaZM+kuQOjJxbWEiRm00UMO4JHRiO9YzZdwNuveAjPTKsLnwsBY0uNgNH+DozpVJ47R/p58BlxOkiU7PYN5JLZImbTRZy3qQddUZ7Tnys1T4waS+ZwRn98WYH0iBVCucLa3p2y3izmSkjly66LB6g6edabkfmsVivU8cUctkr3KiAEqva97gVyJ6Ug8fjAOE/ve/nZgwD4eQHa+/5eDc1wYPwKgDcS0XEA14KnjlwOoJ+Iws422wGMe/+5QYfJzCRe+8PX4t7Re7W2X8uWiWKCrRtQfHrPp/HJhz6pta1s0V6rwLcTu1a0ugAjYwzHl45rFzKUr421XLUGagNzY7/3R76G2sHNoEPNdd8i14gskK1lPSEhUppr2NBOHJxYwgVbetCXiKA7FkaFNa/jQMmu4L4js5hNF7D3ZFK5bbFcQTJbwnCvSCFRj4Exhpl0AcM9MXRHw1p28e8/MoIHjs7h6z87qtxuYpE/P7f2VVeh45FQ26cciFoAOwadFBJnRbqdV6KPOivQ5w73IB5pfsvOicUczuhPLPt5xOKCRsk2AoaMaKEqp09FrdC6HyfGGH7tsz/FL3/q7sBt59JFDPXEan7WCYIjwDvw9CW4OyjIgfH0VAobu6Pud410wP29GlYtYDDG/pExtp0xdhaAtwK4hzH2DgA/BfAmZ7P3ALhxtZ91OnNo7hCms9P41oFvaW2/liv2QljQac8qCyk6SrYc+K51Ckmrij4+Nf8UPrjrgw2tKLdawJCDR63zKDkw1rqI7OmYQlKulPGlJ77UUGcM+ZnQKjHgXx/6V3zmkc9ob98OrpGVPEtX8lxp9XPJYPDi8GQKz93C2/H1xLgluVn1JGSnw8iC+t6ay/Bn+3BvTKtl6VK+jGK5gqGeGGIRvRXisSQfQ9Cq7uRiHtFwqCbtoBNqJozWFTMUK7TNCHAYY66wo8MdByZx9UPB76+jzjVy3qYeNyBr5oryeDLvKWCEnc8qV9r7nK439dcQwAPl0jpf+yfns6gwIFO0UQlIgZrLFDHUW9sIs3McGFm8YFsfACCVVz/zDk+mcMHmamckIcIVT1ERrpldSOr5ewAfIKJnwGtifHMNP+uURwSB8mqgClH0EVg7AUNHYJC3SZWCV+Llsa6ZA6PFAQHqdDUAACAASURBVO8VT16BO0/ciSemn9D+m5oCjC0IPuVzoXNeZHFGR6jZO70Xu0Z2rWhs5UrZbS97uqxeH5w7iG/s/0ZjYoCcatOiArbff+r7uPrg1drbt0Ptl0adK1cfvBqv/9HrtZ/VAnl7U4zW0A7MpQuYSRXc9pWiLZ9OOoYOPx+rpmRNJNX3lrBPD/fE0KXhqBCrlUO9Ue36FCPz/F01FWDVnljMY2tfbdoB/4z2XtF1V8/7qzUwADTF/n/HgSm88lP34Ma9Y1rb//9XP4Z/vuHngeLJ0Zk0ouEQtg90ueNtllCUL9mYzxRrapkIXLGkfGoGfyul2tGjmkIStmjd0xSOz1XnlSpnQtmuYCFbxMbuznNg5Es25jJFPMd5/gaJtsfnMjhH6qZDxDvEGAeGBoyxXYyxNzj/fYwx9grG2HmMsTczxk6PpdE1Ilng9krdNpprudoqnBc6DgwxbgDIFIMDX7mF4Fo7MIDWrOpOZCYANNZlpdUr0fK5WCwG1wGQHRg6198Hdn0A77/n/StaebaZjUSYT8hOFweGuHaOLx7X/ptWp2PIoqpucF/zHGuRA0Met44Y95lHPoPxzDjG041lTbaDWNMuENHriegpInqGiP7B4/cfIKKDRLSfiO4mojNbMc5THeFIOHMjnxRXBQz/ifQz0ylc9LHbsW9EnRIC8FXUEAE9sTBmAuzRQsAY6o2hJ2YhW1KvvM6K7Xti2jn64jOmFtXPmsnFPLZsqA16Y5EQ8m0eKIwu5DDUE0M8wp00zXRg7Bvl51vk4auQr5+T8+pn6tGZNM4Z6ubtOpuc0z/uXN/KFBLjwKhhdCGHrqhV4z6KWOtfA2NqKS/9t/+zYz5bBGPAUE+tAyPWASlf4nl07jDvkKN67uZLNpLZ0rJrORo2AoahxSzkeSsd3TZ+NauGpeY6MMQkPl0MFjDk+gc6gkejQdaPnv4R/nPffwZuV/MZLbbSxyyuBDciYLQ6+KwRMDQKGcor1TqB50yOdyBaSbpJhVXQFeGrAadL4CeEwUZW6lvtPKpxY2nWRal5jtmtqdux0k4os/nZhj6n1eenXSAiC8BXAPwOgOcBeBsRPa9usycAvIwx9gvg7dr1rUgGALwjRRBusUonWO9xBAzVSuD/PDGGTNHGfz8YnB4wsZjHpt44+rsigfZo14HhFOVkAbU4ZtNFd/uopddxYMlJHUnm1E6+iaVcTQFPwFnRbXsHRm33CFfAaELwKYSIoDx9ABhZqIoWyaz6WB+bqa4qR11XRHMCMrebjFcKSchJITlF7fcrZXQhi239iRr3Ea+Bsb5B8rQkYKQK/vOgOec5sNGjBkarUkgyhTKemgyeAwmRZttAAtFwCGmF801su7lOWI20wB2zXhgBo0MQQauuK2EtA95GxiJP/rW2l1Y7dWzulz54Kb6y9yvawg7Q+pVOke4gRCkdasbcAvu/fO50VqFXmsLUyDERlCtldIW5gHG6pJAIEckiS/tvWu08kgVMXaGqpvVrqxwY0jNMdhYF0YhACdSen9PlOvbhFQCecVycRfDi4BfLGzDGfsoYEyfjIfBC4QZN9jw7j4s+fjvuO6JuXS8mxSJY73LbWPqLDeNJ/jc69uyppTy29MXRG48glVeLsa4DoyeKLg0niJtC4tTA0BmPqH2RL1WUgsd82suS3v4ruqML2WW1C4DmpEkIIUKnze64lC40n/F/1pXtCk7OZ3H2EBcwIk0UXICqw+iMPq8aGKKIZ3ufUz9u3DuGv71WP025rPk960UwAIiEad2FHiFQAkBaIX66Aka3lwNj/QXHW/ZP4Jc+dTded/m9bsqaH8JZsnmDqPvj/4ysF5sFxoFhaDkiINQVMFa6aqiDmGjr7Fceh44DY6W1Hhppb9jqQM51sGgcD0G5UnadG61ePW/0vAdtL4sdOukp9cgpJK0qTrneiOtdN6UMqF73IQq13MWjLWA4rgSLrKbeq3bF1r6PVtq9pVExTnaGnc4ODADbAIxI/x51fubHnwK4zesXRPQXRPQoET06M6MO1k8n/ueJMeRLFdxxYFK53cRiHhGL3Ml/LMwFDNWEuJGVeFFLojcexlKAA2M2XUBfIoJY2EK3I6Rkiv4ByEyqgBABA11Rt0uCKuWkZFeQKdpuBX8/QaVY5tvJFnqAH5tyhWk5W1qBXWEYS+aWtb8EgKK9+kBuIcOPV9B5BKpBJQAks/5B2ehCDuUKw1lOCpNuZ5BKhWmtcMuunnrEZ5Xb9HwG8TfX7sUNe8e1BKVbn5zAef90Gx46Nhe4bf01BDhFPNdZ6FmQnDsqR5go/rvcgaFXF6eZPHB0Fn/13cddt9mDAcfbdVX0xgM7L9WLzYJWnJv1wggYHYIICFfiwAiadDPGcNPRmzCRnmhoLDpBUKMCRiPigrw6O5cLfvB6/V1LxIAyP4eNdiHpjvCXeCtaYMrHSefzGzmPcnHXRoQogV2x3RSS02XlWpyPRkQwIQZ0R7pb4uJZiQNDXEfdke6m3qsfvvfDeNet79LatsaB0cA922gNH7tiu46a0+U69oE8fuYZRRDROwG8DMBnvX7PGPsGY+xljLGXDQ8PN3GInc3TU/yZO7movqemnBSPUIifEp02lqIYp7xC6sfkIndgbIhH3PQNP2bSBTePXdRwUK2gzqYLGOyOwQoRYpHglXvhvtgxyMVwv5QW4TTor1vRbfcV+5H5LEo2w9lDkoDRxKKY4vjptKuVg09Vx5dnZ/kztD6FJGi8n7rtEF53+b01RWK9mEsX0R21kIgudzJWU0ja83yqkMd8ZCpYyLnlST73f/Coeh69lC9hMVda7sCwQuve6WIhW3KL0aoEDPEcqq+BEQmF1r3DzM37J9ATC2P/pb8NAJhIqufGU6k8olYI/V0RLrgorsXJRW8BIxrwd52METBaSLlS1qojAdQKGDqFDhsJIE8sncBHdn8En3zok1pjEfvWWRGVV9d1injWODAC9i+EAABYKDSQjsGqYkAr3QyNBDjlShm9UV6JuFljHk2N4uMPfLzhVCAdG30jThr5HliRgMFsN4XkdFm5Fsc3XUxrFz5dKzFAlxoXj2ZdHjHmnkhPU4W7O0/ciUPzh7SOQ0NuohWKHUBtKtTpch37MApgh/Tv7QCWVUQlotcC+CcAbzRFwhtDtC+dXFJfzxOOwCCIBQgHjDE3YAhKCUnlS0gXyq4DI6NISwH4arlYKY85zgHVCupsuugGLTqBrytgOKvLSz7jTzrb1Tsw2n3F/rDjSHiO0xIXAKJhPUeDDkKU0BEw5jJFiBIKeUXdECFgCAcGEWnl9N/uOIsOjAcIGJnCspV5QaSJHVrWmwmpCO18QI0RABh1XFPiePshOpBsWyZgrH+dhYVMETsH+b2qqp8zly4gHCL0JWrv17C1/mkvT5xM4sU7+7EhHsFQTyyw7fDMUgGbNsRARE6NHYVwvJhHTyzs1ikSRFvQ4na9MAJGC/mPR/8Dr/zeK2uCfD/ExNhmetbnRgJI0RVjz+SewP0CVVGiYBcCa080msoibx/0PWVBRFcIAmrdDM2ypR+eP4z7x+7X2lYENrIAE0SpUmp6cHPVz6/C9Ueu1xp3ozUtVurAaDToAxwB4xRwYBTtInaN7NISJOTngW5gLxwYPZGepqWQMMbw7QPfxkhqJHBbeZy6tSREWkV3tLtpY5YdWDPZ4LQC+VoOGrd8/TbswGA2EpHTq5uOD48AOJ+IziaiKIC3AvixvAERvRjA18HFi+kWjLFjEauoALCUUwebk0u1AkY8rBYClvJlN+BT2Z2B6orh5g1xxCOhwIJ6XMDgYxGpLCpBYiFbxKBIfYkEp76IVIat/fwzsj7pKQtOzYaBrjoHRpuv2B+eXAIRcMHmHvdnUSv4uOhQKNvu8Qpq9QjwY7ipN4ZwiJSFWJ+dzWBDPOyeRz5mdUDGGHMD2qAOJ3OSyFWPK0h1YBFPuaPPgiJFRzDmOAFU9UgAntIDoC1SSOYzRWzpi4MIyClSyebS/DkgFx0F1n/MjDEcm0njOZv5QuRAV0SZPgVwB8YmIdoG1OyYqntWC3Q7MHUiRsBoIdccugYAd0AEIQdmzU7FmM3xavnaK7kNtDZstJioCMxiViwwMJOPQ6P1JJrtwHjPbe/Be+96r1Z7SHHMGgnWbWajJ8onHs1aiRadLISApaJRIaqRFCY5naGRIokCu3JqtFH9zqHv4P33vB/3jwcLSvLzQFsMcM5JV6SrqcLd5x79HD52/8cCt11JXR5xP/VGeps2ZrlVs3j2qWhk3LJo0YhACdQ+lzpZiFstjLEygPcBuAPAIQDXMcYOENG/ENEbnc0+C6AHwA+IaC8R/dhnd4Y6ROG4oZ6o0iXBGFvWLlQIAX6r5qLuxfaBBDLFsnJOMenkbG/tSyAesZBXBCF830UM91Qn84A6hWQhU8SAEDCs4O1FCov4vn7fUQSE/T4OjGa4GRphNl3AX33ncbcgpR8/H1vE2Ru70RWtrtA2q42qEMT6EhFki3bgXHI+U8RgdwyJqOUrFAG86OjOjV01wWckICCbThXcwDBIoJtN+zswws41s95pBs1gXkrfWggQJYrlinvfBgkYY073GK8UkvUWepLZIga6ooiHLeV9PS8JmTLcNbJ+Y55JFVAoV7BzIxd/ejRcZ1NLBWxyRNuopS7GObmUx+YNy69lK0RtW5dntRgBow2YzgUvINVMojXs1yJYSYQTgcKBqJYfDoWV27ljsfXdHY1aqmXLeKADQw4WGljttJmNnggXA5q1qiuCyOms+lxWWMUVgBqtgRGzYghTuGlBujg3Ot0SVuqk0bH+ywHligSMUySF5PGpxwFAy83Q6PMAaOze0mU8w539R5NHA7ddSWea+rSXRroN+SGLAzq1OBoZt3xcG3VgnI7ddPxgjN3KGLuAMXYuY+wy52cfY4z92Pnv1zLGNjPGXuT8743qPRoEI/P8Gr5w6wak8v4iw1KujFzJxlY5hSQgdUMUDDxzYxcqTO2QEBX2N/XGuIChCEKyxTLShTKGekUx0eAUkvlsEYOOSyISDl5NF61TNwcIGKIGRr0Dw+3osc6rnVc/eAK3PDmBr/70Gd9t7ArDw8/O4xVnD9b8PNKkuh1CMNjWn4BdYYE1KuYyRWzsjiIRsZQpJNOpagAnCGrZeXCi+kz3SwOSx+HrwAi1RpBqBrIQEbTKP1vj1gh2YMQjoWUdPXgNjPW77gtlG5mijcHuSKB7ayFTXCY2AlygWk9xSriBdjhpLz2xcGDr6Nk0TyEBuHisuq+4m2i5gBE2AoZhLdEpQLnSGgQ9kZ7AlUsRSBcrRb36Gqxc7foQsO9Gu4qI7XujwSuuq3FgiJSDZhQzlI/ZXF59LmVnQiMrtOVKGeFQGPFwvGkr0aJLgo6AIQdUjQhoPdHgdAU5QFxRCkmlar3v5MAvRPxxHCSCAY2lNQjkIp75cl7bcaVCXEMVBE8EVlIfQoh9QnAMEl50aqjI+0gVgwucNVKXZzU1MGxmV51hlc4V4gztzaizinrRGX0oV5ivhV84JDZLDoyIFYIVIt+JtAiGdg7y61hVD2He6Q4w1BtDImKhZDPf9IvZFH+uuw6MgBSSsl3BYq7krrxaIr1DMZFfdAK9qoDhvW8/B4a7Yr/OAa8I2FVdXw6OLyGVL+OV526s+XmzHBgiSBYW9qDuDsIdk4hayhSSmVTBPeeCiKVuV3vIOR47B7uUAWKlwjCfWd4OV7Ce5/PZ2Qx+74v34eRc4/MfL+YcAaM3FkaupA6ShdixYzChLKgKcAFjW39iWTpGdJ1rYCTdezDKxU/FNbTg58AIcQdGM+ZBOggBY6ckYKiejyW7gmS2+gwLatPMXU3Lv6cVoqbV5dk3ksQNT4w1ZV/NwAgYLUIOQLRWwBtcvWxECBAT+nKlrCcy2CX0RngeVyMTeq1x25LwEjCWla52livlpjow5BoOQTn1coDd6JgjoQhiVixwzLO5Wa0VdrH6rNPuUZzHDdENWgGzHHg2FPSt0IERpjCioWhHOzDE9aCT1lAjKK3AzcDAao77ShFpSBWNlYyVpJC4Y44G16y5/sj1+NXv/ypOLp1U7lM+djoChhhDb7S3oZbAxoFhaEdG5rPojYXdQnxpnyBPFJjbWpdXHQuH/FNIHAfGWY5NWpUeMJcuIhoOoTtqVbub+EzQZ9L8vl9WxNPHtbGYK4ExuBP6sLOarlqJXHTSDYQNW+XAiIZDSERqO1e4boZ1Tjk4PMnf43Lhxnr2jvB3/Et2DtT8vNpGdbUCRq3AVAhoyyo7MPzqF9gVhrlM0V2BlsesckUcmkhhW38COwYTys42yVwJdoVhY0ANjPUIzC+/62kcGF/CbT/X6wQYxHymwJ0SPVHlPQhUXRfb+7uQLdrKVsOjyeyy+hcAF3vWs1CkEF02djsCRkBtm/6u5edYCFTr5U4Yd1K8ROeU7lhYWS9GnBeR4hQN+9fAKJRtpAvlZc4YgNfmadZ3vPgr9+Nvv78X06nmtbRfDUbAaDLZUhbvveu92DOhLogpW5d1Vg3lyW1DqRjR4ABStvDrjkV0xMjZehN6nUAWqAa+OsKLHCw0UsSzZqVTEfAyxnDf6H2BQctivnrMREDnh+yMyZayDdUdCRN3YKhcI6VKCRffcDE+/LMPB+6zkVacsiCmK0SFQ2F0hbsaSiFptL4HYww2s2GFLMSsWFsGfscXj2MyMxm4nXgmNOoKaFQM0BHvRlOj2D22O3CfQvzKloOvZfH5cSuu7xqpVAuPAmoB46ajN6HCKnhy9knlPhutJySLd7pdSCKhiCniaWhLRhZy2D7Y5Qbgfk6DKQ8HBqBeCZxJF2CFCGc4k3RVjrcIYonIHYtfMDsjHBi99TUw/FwSTpqH68AIDkaTuSJ6Y2F0OzUi/JwBC9kiBroiy1ahq0U818+BkcqX3JSg6SX/Z8a+0UUMdkeX1S4Q3Vma5cAQ4o9KYCjZFaTyZQx0qR0YC9ki7Apzz7k85qIi3ejwxBIu3NqL7qg6QJxzHCtBXUjWQ8AQK+RBdUx0mXOcJYloGJmAYrpCDBDXhsoRM5HMu/e2DC+IuX7XvRjzQHdUKagyxpDMlZZ1DAKqbY/Xq2vQTKqA3njYbQHdEyBgzKWrIg3An7t+96k4HoMebqJQkxwYsjvnyJR+vLWWGAGjyeyd3ov7x+7Hl574knI7eSKu28ayL9YHQG+Vuqb9YIDI0KgroFQpuQUldVfXdQQJQBI8osF5+iutnVCqlKoChkIM2DezD39591/ii49/Ubm/xWJVwAgKiMTx6Iv1wWa29iq4m0JixZWB57HkMSwVl3DPyD2B+xTHWuecF+0ioqEoEuGEdhHPSCiCeDiuvWodt+IN2+5FTQSLLESt9nNgMMbwjlvfgT+/888DtxUChlZdBqkrjW5KkUgh0Umfuuzhy3DJXZcEpreJ612nG0ojQoCgPoUk6FkGcPFFhXyN6B5rQFNUdbbtj/U3LMY1u4jns4vP4qO7P9qwkGI4tRmZz2LHQEJyPXhP/icWvQUMVe74bIrbmBMaXT/mM0V39TuoOKjoqiBW+OMihcRn+/kMvw/dGhiWjgOjhA2JCBJRtbCzkC0tq38BVAOi9bTSn3BSDrb2xZV29APjS3jBtr7l1v9mOTCc+iHDzrWiOu+iqORgTxRRRTqIqKeyLIUk7F98MV+ycWw2gwu3bgisGSDa/frVwFjPAHfCES7m0s1ZgBHpBN1RKzCFZMFNIeHzAj/RsViuYC5T9CwUGbUIpUpl3dIxqgG7OoVkKV+GXWGe92t0ndvkykWIAdFVRP18BGQBw/96FteNVwpJOERKV40uB8erc6XxJgltq8UIGE3m+NJxAMEr8fIkWncVcKUCRrlSVgbKjQgYdsUGA6s6MJoctDQSLIhx98f6G3NgVGxEQhFEQhGlGHBg7gAA4OmFp5X7k8cZNA75eAAN1AKolLnLIBxTHhc5/SDoZSLy7HVX/CNWRMtRATiOEc2aHeJa7Yv1NZxCIoLycCiMmBVrOwFjsbCIpeISji8dDyxAKc6D1vmwS9gQ49fQih0YivMi3BfHFo8p99nIc0wIVb3RXu3r3nVgOIKpSnQRz9yglLyaMWs8N8Rx03mGiWdSX6yvYTFOdtk14zr+2r6v4cajN2o5aQynB4wxjC7ksH2gyxUB/Cb/k4t5DPVE3SBXEFWsts6mCxjqibkOCVUgO5cuuCuGYlXSzyI9kyqACFJbVLUDo7pCy1dedWpgLOVK6O+KuOkpfivRyax3UcDIOq/oAtUV++ds6UVa0fVlYjGHHYPLV85FELda+38yW0I4RK5gpBSuHHfMYFfUSQdRCxhDHg4Mv785MpWGXWG4cOsGxMMhX4ELAOZEDRa/LiSh9XNgCDElqAuILkLA6IrpOTCI4Dor/NofCxGxXtAEuAODsfVLx6gVMEK+NVdEapNnCklofdvkzjjPRkEsbKFY9hd9Zl2HkFQDw1ewLdZsK9OsGhgHxqsLtcKd12qMgNEAOuqiCMB0J7qA3iS6RsDQmBjLQgCgnvg3UkvC3W+DNTB0Uw9qhBemJ7z0x/pXVhDTiisDBWGPD6o50UhXAxHErST41BmznAIk1+bwQoxby3VjlxAJRbQdGGL7IMeIPI6+WJ92Rw2BuF6EA6PdUkhElw5AnZ7FGHMFgKVCsCugWCm6Iph2S1KpiCegV/9lLK0u2NTIc6xU4WlF3ZHuhh0YOmMWxy+opov8TNF99gKNOTB0a8UIKqwCBlZ1xzRBwBBCTpAjxdDeNGP1TDCbLiJXsrFjMOGKBn5Og8mlvFuUUSasKNgnujpELbXAILYVq4tBHR9mUgVs7I66eetB+xcpJI3UwEhmS+hL8NQQVbDg68BwU0hWH/DuG0niD796f2Cu+dhCVcBgzLvmSKFsI5ktLevmAfDghmj1q9ALWS7+6BQFnZdWi1WtIUUHkf5Efbta/5VrUQ/kuVt6A2sjiHotXnUD+OesX4ArAu1mCRhzaX5vdUUsZANadc5ni+hPRNAb56lTfg6MaTelbLngEwkLsWd9BYz+RMRxJqhbHnunkDTnfv3qrmfwxi/vxvFZ9Tx6Ll1wuygB1To+fvde1YFRrfsTtK2fA8NuQl2eJ0aS2NbPnXtLAd1T1gsjYGhyYO4AXnPda7B3eq9yOzHBDRIZGs7DtkvoizbuwBAChmriL48laNxybQ1Aw4Fhl2CRpR20NCK81Ni1Gwh8bWbDomA3g1jRDbLRN7QKLY0Z0E99kWtgqM6lnM4i1+bwQq6BESTOlSqlxlJInPHqbC+n1azUgRGi0Lo7MP7r5/8V+DyQHTGq4pxlVnYdGrppDY0KGHIRT8A/SBauByBYDGjk2i/aRVcE077u61wjqu8qnhXzBX0Hho7wKTtHGnFg5Mo5/Ro3zveMhqIIh8JKIc6u2FqFXsVYJzLNKQxnWH9u2jeO8/7pVjxyXH1NP3RsDu+88mF31dqPEacDyY6BLjeFxLcLyWIeWzxWW8Mh8g3quDsh6qaE+AUWgJNCIgSMgHoDs3Wrl2ErhHCIfPfvOjC6amtgqNomLjoODADK2gziO9YTaaIl/e9/tB+Pn0zilv3qe3csmUMiYmGHU1jRK6deXBObepcHnkSkFBF0WczxYyKC/qKiiOecFGypHBiig0hvvDb4VP3N8bkMrBBhx2CXsjaCGEeIvFfngfWrgWFXmBsQpgLavuoiHBjxgDQFAFjIlDDQHUWXkzrlV/Sz2vbY24EBrF86xoLjggpbIUQs/5SiBYUDo1p0d+Wiy1K+hM/d8RT2jy7iM3ccVm47W9fmtFqI2D8txAoR+hwBT9Qe8ppTzNWlm8g0y4HxxIkFvHhnP3pikaZdp6vFCBia/PTkTzGfn8ftx29XbicC4lQppXQPiEl0zIppp5D0RntBoIadDPK4vChWiq6jIiiwaEQYEduLWgiNtlEN2n+NA0Mzz1sUfRQdPVQBrxAwggqbilSMEIXWNIVEpEmozqU8VlnM8NpfhVWQCCdQrpRr6on4jTti6TswypUyIlZEK4VEFnVWWgNDHJv1cmBMZibx+cc+j0vuukS5nfzdVUGnGHcinEC6lA5MNynZVUfWSgUMv/Mip7AsFBoQMDSu/UgogkQkseIUEtW1JJ4Vybxe+l5vpLdhB0aQK6y+xk3QfSVwnUROMVrV97zqwFX49et+PbAwrBBedbpcGdqTax85iQoD7j6kbq38qVsPYfczs7hp37hyuxGnld+OwS7JgeEXsOR97eKqlcABKQ3DLzDOFW1kizYGHctztX6EvwOjvpgjd0n4j4N3N+HfUccunsyV3GAhHvbOq2eMIZn1LgrYrBX7qaU8np7iz2BRoNOPsYUctg0k3NVzr7ah00LA8Fg5B5yimKvuQlJCf0J2YPgfA9kdE1E5MJyigeK71YzX529OzGWxrT+BiBVCXKMGxmB31BW36gk3IcDVQe6UklUILrrkijZyJX5vRRWFH93PzzvnLqCgq3ADeV1H69mxBeABe7W+jb+gJZwtng6MJjim9o0kUWHAOcPd+OnhGd9jVyzzts6eAobPM2wuU8RAVxQh5/qMhnmajtczcj7DiydviC//nlaIVp3aM7GYw/hiHi89cwAb4mFle+L1xAgYmkxn+QQiaDVeDrhVga8IWAbjg1qT6GKliKgVRTysV+iw3imhmhAX7AIG4ry9lnYKSVQ/hcRNJdAp4unsPyjIAqpFPDfE9O3acqAQlI4hAqF0Ka2VyrIxvjGwfoG8Qgs0FnyK46ibQqKqwyJff4BG8GlXg08dt4voQpIIJ7RrmTRquweWp5CslwPjmeQzAIJdB/LzQOVmEOMW5yPoHhdFPC2yVpxC4nesZOErSAwo2kV3zEEpS66AoSmCAfpCLGPM/Z2OEwQABuIDWsKnXAMDUN+zsqgKNCBQOqkyYQqu5fK9Q98DwIsMqxDXm05nKUN7cmyGPslm5QAAIABJREFUX58n59XX6bhTcPOpSfU9KApzntEfVwoYZbuCZK7k2aEhYoU8J/1lu4Ilp7tENGh1MVNr348G2LnnMoVlq4uqIo0LmaLbgQQIbpnIGHOLeALcgeGVWpMulFH2KQroWtI9XB4n57L49G2HlV0HBF/bdRQhIoSoWnfAj7FkDtv6E1JHmeXnclqxcs7HvfoAZ8FpVRlkiwd46gYRDypVAXYqX4YVItcZIFAFrCPzWZzptPCNhXn7SN90p3TBted7EWliSpAK0d1hU28ssOWpDqKgqrgPAwUM57oPSv+ZTdemNMisZ8cWoPb+5kWFfRwYopivV2pFgGj67GwGb/raAxhd8H+Hi2KW/+tF25Ar2Tgx5/2crp6TqsAQC6tdavz6jC7b3uvemq8TO2QshWMO4KlBV953TFkE+PETfB74kp0D6DECRvtwfPE4XnXtq/DA2APK7cRkcCo7pdxOntyqVr7kgEU3hSQS4kUUdYK8+pX+ICdDf5xPuIMm9K4Do4EaGI2u3Ivij4A6F1xY0rsj3doODDdQCIUDU0h0W92KMW5MbNQK4gA0lA4E1B4X1ZhlAUUlYNQHzEHHr1gpNnYepRSSvJ1XOgpW0p1CUJ9C0gwHxpVPXonbnr1NuY18b6uCVPlcqcStZYFvwHVRskuIWvopPUDVzRBUT0K+1nUcGLrXUKOFYIHlXUj8ngelSgkM/CWtKyIOxge1uy4BVdFWJeDJDgxA//4W58YKWYGin+gkcGLphO82jDH3/AadQ0N7kimUXcFhNuX/XMuXbDdN4LjPBFowtZRHd9RCbzzippB4rQAu5kpgDBj0aT/oFTCIQEx2YPiuLtYFQ2FLnUOfzpeXpRJwS7VPCkm2WBO0uA4Mn0AnU7RRLFdqWhZ6pZCI79iX8FrR9Q+I/u3WQ/jPnx3FtXtOen6+O45CGdc9OoI3vvAMvOzMQbfugB9jSe7AqKbsLD/eQgTxSiEBeIHT1VrMF7NF9CUiiFrB3WempXom3M3j/dmpfAk9sbBn5xRfB8Z81u2mEVccE8CpweLTgQSQupCscV0HIWoN98ZQLFdWLSaJlrb9zvkIEjAWcyVsiEck0dGno0euhN542NOxEnEFyPWrgTHopp/51+RJZnmBUi9nQjRAdPnS3Ufw6IkF3LjX39U2nsyDCPiV84cAAEdnvGM5EfBvkJ4bQYWO5+uuT7dwscdzSdQ88SIcIlR8UlnLdgXvueoR/Osth/Afd/o3K3j85AJi4RAu3LoBvfGwSSFpF3aN7MJiYRHfO/w95XYiYAmy42oHLI57YGNio7aNORKKoCvS1ZgDQyN3vGjzgoAhCmk7MLoiXQhRSKu+ge5KPCCt9Fu8IrLqb0oVHsR1R7qRLWW18s3lFfsgN4P83XTdNLrHTxTx1DmXIu3FTSFRiFF5O+8GTzqii3DeNHv1XJx3IUQFnsdQFIlIAgW74J4jHUTgFw6Fm+LASOaT+MLjX8CH7/2wcjvZTaF6JtQ8DxTHuP586FxH4r7SFQNKlRJCFEIirL63xGeHQ2EtB8bGxEYAwcLBqhwYATV3xD0Rt+LIlDLKZ4F8rBsRMHTE4GUChm6qjCPE6RS+Fd9NlZJUqpRc0TCoFo6hPXnWKQpnhcitSO/F6EL1ngiqDj+1lMdmpzCnqo1gtYuHd60Hr0m3SA0Y6I5WVxeDis7Vp5B4uBcYY0jly8tSCUROuBcLzoqkwHKLePqMxy0sWe2K4uVmWMotD0QEqiBOnMuHjqnnj/tGk8gWbbzxRWdgQyKiLJaXL9mYzxSxrT8h5dMvH7MINrzGDDhF/lYZeIr6ITpFPHk6EL8GY+EQij4Bs9c5B4QDY/l48yVerHSb001DBHx+KVJzdXVVvD4H8L4mm4lY+RZj8au9oosQMPqc8+F3DwqW8mVsSIQlR4D39nKNmHqqtU+8/zZTKOOKe481t8aHSCEJ+TtylvJl9ETDns6EcIDoknLOi0i782I8mcOm3hh2OqLZ5KJPWq5bz6V6PQfWwMjUirCqwsXzddvKqATKW56cwKEJvlC7+5kZz20A4MnRRTx/Wx+i4RASkTByPsL0enPaCxiiwJmqXgAgCRi5AAFDmniqhAk56C1Wim6hOC8YYzWrl1pFPFljKSRxK661MioCCjHR1iniKdfACMztdwKzWJg/zIOcI9EQFzCCctMFcsCrIwZs6toEQN/NECRGuS1Do/opJOJcWmQhHo6rO8qUCxiKczVYNRZxvQ3EeMAcmLIgdSEps7LyegVqU4eA4PMorm1AP60GqAZ+FlmB1vvZ3Cyemn9Kub+TqeoKmer4yaKFUsBwvjeBlMU561N6dFJIGi2IaTObF4K11O4m8awYTgxrpWMMxpw0JI02qvKYdQRHcX7FteF3HYl7YmNiI2xma6V56DowyhXuJtK5PsV9sRKHFQCt4sJinyoBQ4wxHAojWUhqFxM1rA/XPTqCf7z+SeVqq1jNe9mZA26RNi+EuPHcLb2us8GPqaUCNjvBo6oKf30FfJmIjwOjWvE/qlwtBJYXnVO18yyUKyhXGHqWCRiWr8ND1DcQBDkwZkVKiyOoJPwEDFcMWB5Yuyv2HgGvKJ4qalv4cXiC//6iM/rQFbWQU3SQEK6b4d6YMhjKFmyEqBow1bPaIn8lu4JM0eYODDeFxD8In04VXDeIqgDjUr7svXLu043B75ryE1PqA8R61stVILp+CAEjqGvIvpGk0pmzmBMdOqopJH7Pf8YYTyGJB9etWZRqxNQT5Gb4/E+exmW3HsIdB9QO9sdOLOBt33hIKcQyxrCQLdaIn37nKFMoozu2/F4Vfwf4C1RCuFCJxxOLeWztS2CgK+oIzd7P32o9F68UEv8Up5qaGYrW0fOZ6vGoJ6yogXHL/gls60/gfb9+Ho5Mpz0FUMYYnp5O4YLNve44VMWZ15PTXsCYyXHVaSqjvrFEAJsqpZTBW76cr9YVUEzoG1lxFQGscGDo1iAApNzxgFXDiMX3resgcF0VAYU55UALCE45kWs9BG0vp6cAeu1A5WMZC8cCxYDhxDAAdTDbyIpufRvVRjrKuCkkdt73hZS38+iJ9iBmxZRjcUWXRAMpJNJ51Cn2Kq4RICDokzqcBG1bjytghILbqP7Dvf+At978VqU4MJOtqtByC9R6ZNFCVRcnX84jRCEMxgeV7VHdugwxPQdG0a7WxGkkhcQKWVVx0OfeEtfGUGIoUJQo2AXEw1z81EohcZ5hFVbRKnApxIMgJ494Dgk3iM6zV0c8dsftFKRVjQGoOusadWDU3OMKZxhjTEvAEH+/uWszipWiVgFlw/rx4R/ux/f2nHRXv7w4NpMBEfD8bX3IFMq+z/wFJ3A7d1MPUoWysvPClNQatRpwe4kRwk3hXfzOS/RYkDp/BLU5nUsLwUCkkPiPxV29rAtE/CbSlQrDdKq2BawVUMRzPl0b/MYjIc8aGCIQ8QqsRc2E+oA8XSgjW7QRDYcwupBVuhPGkjnEIyEM9UTRHbOQUdREEKkhwz2xajDkMeZs0UZ3dHkqhoCnBK18RVVOq3FX4pUpJHlXwPATIwAuFnk7MLxTBuT2rIB6hb1kV5By6rX4YYUIcSri3XveCNzyQd/tVkumwM+xKFKbL/ofu9GFLC7+yv141zf3+G7jng8plctPJMqVbJQrrLYGhs/5UAkYbgqYT/FWUUj2yLRawPv0bYfw4LE53PCEf/v2VKGMks1qinj6Oj+KZXTHLM/fVWucLB8zYwwnHQFD1dlpYjGHrX1xWCHCxu6o77ZuCon03HBTdjye18Uyryc06FUDw+PekltS18NrYHgfn32jSfzi2YPYubELjAFTi8vHP5suIpkt4fxNPc44/IsnrzenvYAhJoEzuRmlSpkpZVxhIsgyPpQIXgF3g14RsCja+YkJdqM1MEIU0iqGWbALiFkxrSBEdmDotsisSSVoouAhOzCAxsQAnRSSvC2dS0VAVLSLCIfC2BDdgLydV6ZArMRiLgc3MYu/5PzGLdw03ZFudRDndE7RXj2vVGsuAHpClCxgqLYXolVXhK9wN9KJxK0dEHA+K6yChycfRpmVcWDugO/+5Bo3s1n/ADFdTLvi4FzeX8DIlXOIW3FsiG1QpliIcYtaNKpr2XVkNZqOIVrxBjgwxP500tuEkNIT6WnINQLonWe7wlOnRI0TX9HFESJ13EdCZBD1RrTSdSisJd4t6zK0kuLCijo3xUrRdbGpisLKLhoguEivYf2Qgy+RWuDFs7MZbB9IYLA7inKF+adLOM6Hc4d7nH97C4OMMUwvVVe/1Skk/sXv/OoWVFsWRgJXr+ezRUStELqdAo2qIoDCdr6snablLTLMZYoo2QxbJQHDHY/PSqRbVNQRVGI+XUhESodnDQyLsAFpvOqBPwEO3OD+XAQ1rzhrEBWGwKKAZ/QnQETcqq0QMGZlB4a7Ort8+2yxjETUO4gDVu/AkAWMahDsvT+7wjCbLrqdLKKWBbvCPFeIUx51TwAhoC3ffrbuHEYUK+wizcJLoJN5lXUI/YVx4JErgQChe6VUU0j4vZYt+c8fdz3FF1iemkr5BqW1NTDUooSbEhUP7kKiEjCCUkgmFvmcYsonxUIguu741ZIAJKFUqoHh95xJF2z0BDgw/BxooqCqyv22lC+7aTUDXVG3WOfy7ZZ31Kmmtfk/S+UaGFVRuPYetyu8ALGfGOfXhSRXtDG1VMA5w91u2tVocvmzSYhO528WAoa6u896YgQMR8AoVUq+Fu+CXQADw5buLQDU6SY5O+dOGlU570KU0OkCISbFrgOjgSKKOsKBLASohBR5LOFQWKsjRX3Q0qjgoQoARPAkrN2NdBQISiERXQ10xaiYFXMDWtU4RPCUCCcQCUUad2Bo2P9jYT4WrRSSeOMpJIDeeRSpQ2JcftSnkDTSiUROr1E5MORgbyQ14rs/eVVbuLO8yJVz7vNAlRoiHAq90V4tAUOnIKbNbDCwFdWTkEUw33QMyYGRKWWUaV8Fu8Dr0ETVghlQW8QT0HPalColWCE++Vbdr3IhXUBPcBRFObVSXyy9a98tthxpLB1KOImEwJSzvf9Ovk9V15343OGu4HeRYX2RV+nExN6LsWQO2/u73Am4X5V4MdndMeA4EQveQW+6UEbRrriTYlVr0XknGPSaFPOAwasGRlX0ECnnfiv7i9kS+roirivAz70gxg1gWSDit3ovjumWDcsdGH41MJalH4S988aVDgwrhDdYD2PL3MM1K/biWL5kJxdMT8z5v9/mMkXXNs4dGP7OG9eBEZBCkinavjZ6gB/71dTAqFnxDyjiOZ8pwq4wtz1vJOzffjNdWJkDQ5zDsGKF3XUYKRwYAHBuaEL6I/+iyatBLuIJQNmJZP9oNZXZL10hmSshYvHuLapVfqA2JSqoc5DSgRFSd/kRwsRizl8EyhVtTDqpIycVdSfq71XehcS/9obftR9RtMkV4xjujSm7c6TzZfe51KvozpHyEDAiCteZSFup6ULik0Ii9u1/bgi2xzNkLFltqS1Eba9rajzJj4Wo86EqnrzenPYCxlJxyV2Jk+3jMiL4EvUQVIFIvsyLKFpkaacdAHqrem7+uOaqvW4RRSEEiGKYKurHolUDQ9N+LcatGyiL1rKuA6MBN4NY6fRLIRFdDXTSgYp2ETEr5o5DFXzWuGk0xaiaAn8aVnotB8YKikY2ImDUX39BKSSN7FtGBNdWSF0DQz4WY2mFPbGYQiTEXwRBAsZgfBBhCgc+DxLhRKCAUd+FRHkNiXuw0Y4elTKskAUrZCESigSmkAwnhsHAlPeVe+2HNQQMqRUvoHeebWbDIj4pVjkThLDRkOAYDRYcAUcM1n2WVmpF1RWlkCieS+I9MZwYxmJh0Te4cQWdOBd0MkW9Lk2GtWdSyu8Wq6We2y3yNIiqgOHTcSNTRFfUct0SfhPu+g4a1bQKL9dDGdFwyO3kIOPXtnAhw10VXVELRORbK0OMRZ5wq1ZD0x4F8AD/bhSic8vWvkR1/wE1MObS/BiK7+tXqFQEfPX1OPjfEF5MR/g/cvNAMev8DR//Rdu463JE4cBYko5LImqBMf+AcsZpRzooF031CFRzxfKyVqQyq3ZgZD0cGD5jnk45c2knYAorVqFzRdtz3H4rynN1dUyskL84Iqc7qTgzNC390XHltitFCBZCuMorBYzq4qlfbYZktoS+RBREFJgWsiQ9E3RqYPgWgrUIcRSw7ZHLgNkjNb8rlG1MOeddJWDIzqRpRdrGcgcGL+rq9S7MFMq+DoyIou6OqCV01sYu3+duya4gV7Jdl1BPPOzbJjmVLyNEQHdUdmD4iz5uDSKpBkY45O1SUxUW5p/jfb8IsWK4N+YeywUPt4kQ3MX1GVe0r15vTnsBI1PK4IyeMwD4F2oUE+1NCT0BIxFOoCfaExhAWmS5qQSqCbebtmHpF+1zVw01unm4KSQaHU5qHBiWXgqJ3FWkka4lQeMu2bx2QiOpB+5KZ4ADQ4yzP9bPxagAASNqRd2ASLXtSsUooFqoElAXM4yH4+iJ9mjVwOiL9YFA2i0wGxUwdGtgiBoswMpSSMLEz2exUvR8kcn312Rm0nd/2XIWQ4khJMIJZW2LXDnnChOq2hZCUNoQ3RDo1AD0ingKsUN0btGpiQPUiQGKdBs3hSSudjOUK2WUWdl1YASdNzdVqIHgXlxHAJSdjNwUEs2ULzn1TKduja7AtlIHRn2hXr/vKY7Z1u6tsJnt+y4Qfy+Oh3FgrA+z6QIu/fEB34ksUGujXvARMEQdh80b4u4KYqrgve1Clnfc6A5watQLGEJk8FqBzJW8g0fAcWCUSsDc0WXj6JdcFX61MsRYZAGj2vHBw/XgCAD1okHUR2QQnQC29ns5MLwD9RNzGewY6KruO0yeQd9SrozemHcrybAVwk4R8LIKkDzp/A0/7mcPdSNE6px6Hnzy49LliCl+53MmVcBAVxQRK6Qs8Jcp+J9LPm7CGfkjwMjyugr5ko13XvkwvnzPEY+/5HimkPgKGMI1ws+NpXBJ5EsVpYBW/56fcwQ0EbCKFW5vi75eCslOTCNj8UUFLKpb4PoRVEA5UygjFg65Ap2fAyNXtHFkOo1Xncef6X7X0WKu6KY1BKWFuA6MeARhK4QQeW+bL/E2w6pV/v9t3YdtB68Ebv1Qze+mlwoQh0AlYAhh76IzNiiF3fk6B0ZEIU6mFQKG69DxcG8IcWjnYDeKdsXzmGTqnGG98YivA2Mpx1sCy91QwgqBba6ungvAn0nA8ntl0XWF+X1Pb4EyKVL+ElH0O+fVK/1wOsVbb4v3SyygMOx6cloLGEW7iHKljG092wD4p4a4AoamAyMRTnALv0bQ2x12JtG6NTB026g6KSThUBgWWb4T6Qqr1LQjXYsaGI2u3MtOgyAHhmxJD0p/kccvAt6CXfC8EUVwJ8QAnRVdLQdG3eq5jhglF6rUcWCIdJag6w/ggaxO8daiXVxZColGFxK3uOMqUkhCFELU4g97r+KQ8rFQ1azIlrLoCnehP9YfaNGPh4NrW+TKOcTCMfRGerUcMW5tFE1Hlu41BFTrSQBQdroo2AWEKYy+uFpcFdeQtgOjQREMqHZOAaBMrRA/100hkZ1bWuPWrMtTf91rt1GVuiOp2qiKc725ezMA+Ipn4u9FCompgbE+fPzGA/jWA8fx08PTvtsIh8BQT9SdRNYzn+V1HLZsiLnBp19xzgWnm4JY3fMr/OhOdOuEA68VyFzRRsIjeAR4ysFbyjcCX3oJcPhW9+epfHmZq8K/w0S9gOFM5j3GIsSg3lhdDQzfFJI8olbILfIHyKuX3uM5OpPBuZu6q/u2vFszKlehQ4QzaQrJxA7nS3Knnwhq+hMRbOyJKQUMWdiJRdRdCmZSBQy7NTsUXUiKZXRF/VNI4lTCRyfeD3zzt4DFWnfiTw9PY/czs/jcnU/7BiyygGGFiAfBPl1IZpb4d5e7kADeQWSuZCMeWR6iREKE14f2oPLg12p+nsyUagU0yz9A1U0h2YYpnOx6Hv9Hxn/e4MfoQhZn/+Ot+MlB/yYBIsgW91vW5z4/OLEEu8LwmufwZ/q8T22GxVzJDUiDBKX6Z4LfPeVXSFdghQgvoGP8H9OHan4njvVQTwyLOX9h96STWvXCHf1IZou+YmN9i+dI2F8EC0ohOQOzeNHuS4CJ/f+PvTcPti27y8O+PZ7xzvfN/V7rqbtFa0JqIYiwwRAGQZhMUQyVskPsYENhKJJyHEZTFCaRQyqIGJcZglMgCAEERIgWloxGBJI1S91Nq+f5jXcezrinlT/WXmuv4bf23ufpvVZMv1Wleq1799ln7fGu3/f7Bu13AkC4c6Mv92OOYwNY5RISGnih/FzCGoDtiJCFOBkYDRKSwPfBGAfF1SG9UvocvFrpRU4GxklFjlcHlr7Y4yUNYIii7eyAMzBci0GxOBYARm1hk0+l5r3JSE7t2tdRfM2iNymSxshQ0bn0PE8mV9TtW9Cem4ohM4XkZnohALwgDTxOcQ/9sDEOMfKjxSQkTKdqF6wgTTdFR7cbdjGM6tkMVkHU1s+kJf3fNKoEGjwwSgCjac4AJIh2qyQki5ix3gwJCUCfG3FNTvRO1EYhT7IJ+lEfK52VWmaFZGBES80eGAEHwY6TY+ciUFyPXthDL+zVpxIpjKxFJSQSwKiR2wgflaWo3iNCBTCG8bBRpmACVa28fJQ51zETTAZGk9+I6lnThjmyUKJOECPwg4UiblVpWx24JOba5Mck5ijORxt/oNvjCx/H5UL3iZq4zOtHM8Shjzs3Bs6OpGARnF7pNmrT9ye8cBNu+66O/dGUWhTT3blp6gYwwsDDV+ef5P/nkfvlz0fzTGNJRDXadFtC4i42R4R+HODF1quSB4EH/kD7+dXDKU6tdPRuZ+D2wJhnOZ7fm0gTVDH3jWwLePovtW1dyRgAEBVznPb2cWn5DeXGV+Rn+PwjnBh2nPT4JOOUdHFemrrnO6O59E2oS1SYJLkziQEAXpN9HjHK+/Cp92u/++wLLTwXJvp9FYe+EygSEhIxbxczJs0L5AVDN7TnHXs5fj3+PxD8xU8B24/Lnx/PdXApkh3uG/fAOIVdbEfngM4KMHZLSl3j/Y9wIPNtH33Wuc0kydHvBNJo1SUhebo0trzvQin7dcStqiyepndHZeLJ72kXq0mApz0HEBYFPl7tP8v/z+gaMKvWRAJwOLfWq01Iuno4Qyf0cfeJIQpWva/MYRoACyYDBbyM527/lzDw8f3he3H62geBv36r9rud8Rxx4MskI4pRVyWL8P0PO24JCZWGIhkYNV47S8b7FLDvZwqYVkf5Mes9fzCtAAzxXRSDZEsBSgHUJh692OM2gAHgzPAMAOBw7lgMpu0YGGmRIiuyVh4ESZ6g43ck1biN8eMii39t4R/ULPzLIkYwCBZiYES3hoGhUsabAIw4iFudQ3P+TXIMAVqJQqeOgj3P54j9uJWJp8qm6UUtJSQG6ALUR2D2wl5rDwwhHWpz3dsWcYtu/4VISFRGjWRgEEae4vpdWL6A/bk7vWGSlgBGvFJv1lsCGE0MDNUDIy3S2vQYAK2YUOL4VB+VOqNNMQQ4CPBnywlgCBZPCa66js+acwsD4EWieIHKtwOol70sYoJ6owyMyI9q2Wxi38JDpa1EDNBNPHtBT0sbUYc4Z2cG/G+WC2RTjViBekDn9rh5Y6v0t9h26NMBXgieGHYw6IROurjo0p9c7tZ21wFu4rbcjSSV2bWINiUkgNCP0wULRd8XnzmP0txwu+q2Hs90unbou9MBDiepRnmWDAyqAJfFkz6foT/Hv0t+FnjHDwFbj8qfXz2c4cxyT9s2qKGZP7c7QV4wDcCIA4bf934G+J3vAF74pPz5UQ0DIzji5tCXll5XbswBjPGc69+7kY+Ty24Ghnl9mvwLtkdzmVzh+x48jwaAJkmOXuRmYLw8f7r6P9ce0n732LXqveEyVjycphjEgSywXEUwwIuhlV4k7y2XN8nMcc0BYGOmmGk+/1H5n7zLrdx/NUk4B5MU3civTWdBMkYfMxwFa8BgA1BSyT761A7e+hePOVkCYlxtSN0A+PM6iEPJkpk4gIlnd8cIfA/3nuaNBZdc4aA0yAWa76GqUBbbB44kG/4zlxQp8Bhe4V3CtMeBdRxX5qcCLDq32sU0zd2mtMcckBPX0PUe2x8nWBsoBsDyOuvHmGQFkrzA0AHehb6HN/glAGbc97ujBBvDWB4v9Z4WbIthyQzrRgFmKS2tmKWFBQhXHhg046UT+hIs4MdJS04oYJr6nsKYl3gviXkNOyEJiu0cz3FiWQUw3IlHL/a4DWCAAxOhFzZ2s4bxEL2w517QK137paiegSHd+29AQgKgdfqHmI8zlk/R0/ejPub5vFUMaFsGRlZkuolnQ4yqSnNv2n9apAvHqJpUbYDu2ItrKcCApoJIlZA0eWB48BB4wRfEwKDOY1qkyFkui89RMmrs+IsIzKbicxFzVTGXtlKgL0RCosprJCBF3Ovi+l1YuoC96Z7zvEwyLiFZ7iw7AU3A8MBoITVpYjOI50rcR3WFr8rIahtrCxgSkoZIUiGDA9xggCYhiQYYJ+NaXeSiMiSglJC0YGCI56EX9tAP+/XgsWH+25Z9JNhsbcA4AAvJe0wTT4C+pm0ZGOKzbUyIb4+bN0SX2kXvBkrPikGEfhQ4ixURx7fawldAUND7nfoCiAIwQkcE4TTNncXdkI2wgfK+U3wwRvPM6hhSgERRMBzPdblJ5KBHA9VxC0aCGHdNlThshTmwdTSTMZ1iSLNIYj5Pb/Pn/+UnKgnJudmTOOmV7INH3il/fjTLyAQS/ksOWOxGZ4HBSSkhEcWL53k4USMhOTQ6onXXnTEmCz4xIp8+31T3Vx3n8ss49FaAM68H9p7Wfvf49WPcc7KMC3eAciabJq6JWVRjfAG3keG0BDCpTLQnAAAgAElEQVQ6BIh2YqL4cew9I//zyATQamJU98ZJI/sCYw5YHPgrwOCExsD4uXc+jF/5wJP46FPuqHWAs60At+EmwJ/XgSIhmTo628/uTnB+rYd+HCAKvFqgUsqQWnhg9KIqrYQnTNByHgBOVlY32UPHy7C3fl+540qKJCKZz670kBfMyc7hgFxHAXLcUrjVXnXtXMwEwURzS0h83O2V89x7Gsir87lTzkUACNT5k9K28p3XrZFWTNPcupfrUqCOCMlJ5GCpNTEw6kDCbvleAjg4RZ3z3XGip6E0AOov5nhJAxhicTkIB7UFi1gcd4NubcGiLqLbmHiqVONWEpIFijyLgeEADkwpAVC/oDcNRafZtLZoMQ3w2tC1Rce1H/ab9eZBhNiPEXjBQoaYoR+iE7oLXnG+VDDANcS1bBujGgfcIbo1gKEW6aFbJqECaINogJzljbGTsnvekv5/oykkbcxYO0EHvucvJCFRwZ06CYkAHc8vnUdSJM7nZ5yOpYTE9T7IigxpkXIGRoM55yybSR8VdR7mUK9HU+F7I+8DQGdg1BnYqj4qgNsAUjDDxD2UsczJkBDzXpRpkxWZlkLiujfkvR90GyOEpWlxy/hlYSwMtGOFCeC4rV8RYEhI6phh5Xef6td7YIjtBtGgEdC5PW7OYIzJbpjLnBOoiqd+J3A63KvJDpKy61gwCpq0MH0cufY5TRH4nlbkRYFPFniuBAgAOJmUMdQXvhKYHwFzfm+NiAKSYgQczzMwpi+4fd/jaRjEYn6eFYgDX5OEAMD5edk9jfrA9QrM2Dqe4+RSV9u2joHxzA5//l+2WQEYF0YPAADY0hlNH88ZGA42Q1ngHgRrwPIZ2YVW2SwnljrYGdG+W2YhUlcojOYZZmmhARg8bcDBwKhhGpzNXsCl4A5g9TxweEn7jquHM7zxZRwEPXBQ+k1fkI4jHQbgEhIVXHIZGQp6eje0S5TN0eOYswj58nlplApwqZEKLtXJag4mbQAMfj0P/bUSwKg8MMQ9o6aCUENIZlzyG6Dym2kCKp/bHePOjQE8jz/DI4KBURQM4yRTGBUNAMY00+5n17WbloWti5UVT7jHx97qa8odX5G/2x8n8D3I6NypQ0YiALm+kMLVALHqnEMHM0F8fuCQvcTpEda9EY5657nprgJQCQZGxWCx5yzjnUsAQ4A7lExmTkjywpoY1aNZaplyhoGH7w0+iG987zcB1/5G2zbwPSmpMUfgAG9naSHfMQAHekxQjDGG0VwHbStvnr8FDAzP87qe533C87wHPM972PO8ny9/ftHzvI97nveE53l/6Hlew9vixR9ikdtUsIjFYD/sYzl2U8bFdqKArKPtpnkqF6r9sF/PwDCSK4B2AEYbBoZZyKrH4dovUFKdwx5yljcyNm5Y+tLQ7RTeCZ7ntZJBaPNvYGCI89XGEFNNcQEaGBh5unCBoyZtSAZGA+giOv7O7nlRdc/7Uf39B9iSkLb3XxsvE1HYep63EO0eUMAdL6hl+YySEbpBV8rAXD4Y02yKQTiQEhJqoSmORQUwXCCeSCFZipfkPKgxz+fwPR+hFzbeyxQjq+19pL4TXFGdAnRpM2cA6PiddvKpG4jL1eZcA8TKez/sNILHQkIiweMW8inBqqibA1CxwoBmsEMdajqSOD/U9VmUgdHGhPj2uDljXlKWATqOTgyZGhKHzsX8oRKNVxdvWBRMek/4vod+HNSmkCx3Q9lxA9wsiakjAQIANlJemLPzb+I/GPHihTNBDH8NqrvooDyHvudkYMRUIZtcxjZbAc6+Adh9Us5hkuQ4ZTAwPK8ESIgC/5mdETaHHW2Rfvb4QVxim8ju/HvATuWzcGQUydoozwMveE/KgmiqABgrvQhZwchOp3le6orPbZnmoYABhGlqViYo9GskJGfSS7gUnAOW7+AARvm37Nohf3e95twyPy4HKKemXgCc6k5dR8AGl1weGKIIpO7BpdkVvMBOIFu9qAEYtoTEHc27V8oQaocApLwVoL8h//8szWXR+YJDViOG8JjYn9DpaED1rAUliOcyQN06muN0CQJQxSYAzLIcjFVSj0YAY2ayZ5o8MOoBjO2V15Y7rgCMvUkF2Kr7MocEMAQTxcnAyEgDYJthwI+jQxjBAkBUznlr+dX8B4rsZXc0x8agI1lfFIh4ZBibdiWDxp43T9TR51EHqh7PMiwZ78fYB348/EMMJ5eAj/2q/Dn1XldH6DDKnWe6TLAfB5gY4PckyZEXTHuuxN8jdv3zlkfQiz1uBgNjDuDrGGOvA/B6AN/sed6bAPwigF9mjN0DYB/AD9yE77qpQxRtg2hQq3kXi8FexCnjLmBCLhrLgmWcuinVomsPoNEATzPxbFmwWBKSBgbGjaRotClmVSmBB6+x8M1ZjsirNORtPDAAfg3bdqGBKoUEoAteUZzJRJk6Q9ZyHr7nN8pN1OvS1uRPRiz69UW6WrQM4npDUVU61CRZYIxJKn/gB4j9uLWEBAB6Qa+x6BOg1SKmlIDCwPCD2njOUTrCMB5ircsNsFxJJNIDo7OCrMjIucj3QSkhyYqsOdY2qmdgCBmS53nNkqUb8MQBSgaG38zAEMajvbAH3/NbmXi2enfk7b0k5GdYqjEwXKCLSE6J/KgVA0OADE1mt2LekoHREFub5MkXJiFR3ktU4orY30Z3A4EX1HpgCDPkpgSc2+PmDNV0zkV/BqrUEM7AcBhuztKSKu7Xao6FP4TQeXNfDYeRHGFox0EGumBx0cVXUk6bz8+8nv/g+JoGpIjh8tegpCzV9hQDIycBjLX5FTzHTqHYuEtKWQRl35SQyGMlioVndye4uNnXfrY2eRaPFueRrt/DC5vZoTxGF1Ubo+uYIcYIvbJjz8/TXClexPmh/AtkR1eJKwRo/4JdGSWpSEgC3wICROHVix1L/ek+losDPO+dA1buAJIRMOPSmSsH/FzefWKI0PfIiEXAlpBwJoh9nhljJYChzrm++KTuwcFsC1fZOtKlO+oBjIYC0QlEiSEADH8VGGxyD4yi0CRAl/br/4YJA9e8YPKYzDFX0laiwHNKhg6mKVZL0KUfByQQIBhdAxPAcHlgGICcK4WkSUIST3g0/VH3LNDf1CQk+2MOcPVqgIksL7A3qbyB+LG4zYjNJCXAZmCI89ghjGABICrnvLVUpsyUAAZjDDvjBJvDuCGeWJeo1B0fZYosGEI5GddsMzDio2ex6ZV/75//mLJt5vS/AADfc4GENgPDZL2oBsRidKMAfcxwz5+8mXsE7bgjlm/1+IIBDMaHWB1F5f8YgK8D8Mflz98G4Du/0O+62UMUOoNoUJs6IJkVQbeWgaF1vaIhcpa7Kc9l1x5owcDIbcr4okyGRg+MlmaYKoNhEYNG3/NbddfTIpVFViOAUVQARj9cjIGhyTGIosiSkLRgYABoLD5VZowAMJrylEmZBDFnGf0adBs74qKIa1Mwq9ccaC7ixGfa3H9AxaQBSlbKjXhgeEHlD0PcM6N0hGE0xFqHAxgU20oAEf2wL+NMqe00BkaHd6fqEoxUBoZLjjHP5/K+GIT1YJyaHLSwIaYKBjSYeIp7o4mB0dZPQvWSaB0hrPh21DIwyuQUoASEW3jWAGg0u1XnDfBrXgfGqc/3IveyBCkVJpGLgdELewj8oJENKPYziN3X8Pa4eUMU5uuD2KlPT/MCR7OMdySjEPOsIAEEtSis66IKGrlYRHMnfBo8oWQhoYuBUROjOsx2MWUxsrW7y0lckwtfNWYxcAAGLs22q3OfZPpCW4zV2SU8z04iX73Ii8vpAbZkTGfX2j70PdIDY2+caEwGFAWWJy/gWXYayepd/Ge7T1bSF0cKCUZb2MMqP+bBJi+AGdMkJKIQGM1tNoNZJMaBW38vkj9UGQTFMBHnMwocS/0dzlx5TgAYgJSRiCScs6s9DLvuhAUTwHClzxxNMySZKXup98CgGBj92TVcY+tIhueA8RaQzpDmPMFFLbTqkm3q4jWrjTiAsYcVoLfOZQbJsUyRiUO/NhKXH3MKoXw6Jq65ONbqmrsYUTmSrJDeDx2Hz4gAL4WPRFOSDZeQKABG4JPpEqIodyYTTa4jZx5G4TowPCXBO6D0rOjHiseH/X7aGydgDNhc6kiWh4udxov75nhRAfhS7w4ACEccwLg61BkYx3N+n24OO7Xnz2QJCRCKAqooU+SgRkJyTKQdda59GgDw1Klv4p4dc/63vy7aGWj2wBBjEIcWaCSTVgyZ0d/xFf+hx/4DvljjpnhgeJ4XeJ73OQBbAN4L4CkAB4wxcTYuATjn+OwPep73Kc/zPrW9vXhM0RcyxCJXABgH8wNyO7EIFbTqNh4Ykn5d070Unbomiq+meW/JwNDSPAI3EGBq74GWDIyWVPBFF/RmCkltIZdXdO22DAyVql1niGmCUXUJEklRFURN3V/N5C/qo2CF7Ki3mnMdA0MBXURB6fQvMNgrba850AwsFazQzBcbr6NyTnphMziiDrXwqwPgRgkHMFa7qwBAJpFIqVhUARjUO0EFMCQwQRSSMpWohRxDLaqbpEVfiISkTTKRkJAAqO3eq0k2AjBzbcsYs69zyxhVmUJSSsoowM8EEdtISMS2bU08gfp3qdhWgnHh4h4YTc/4JJvI9+5yx+2/IqRLQP01vD1u3hDdqjMrXbc550SAHFGt6ZtmxFfjgWF27TkNmP7uCdUFdPhU1Jp4JtvYYqtIelyOh+PrsvM7NFIg6gAMS0LiKHznlIQkSzCcX8fz7CSS5Zfxnx08Jz0H1C6/GC5A5WCSYEUxBcTxVYTFDM+y05j1y2Xr4WXJsHEzMLaw760iL8AZGNkMSEaahEQAPEcEA0MWiS3o/4INoUk3fFtCIj7rBDB2eff0Oe8ssFwea0n/Fwkap5a7ZXHj9lZpw8CQ12a5ApeaUkhM2j3yDN3ZNq5iHUn3BP/ZeFsCeRQDgzY2zZ2eAXKMtjHxepghAnq88YHpvnzmLqz3sedgpQClJ84sw9lV/r6mPCsA/VlzGaDuS8Cq8kepZWB02ktINHlAVM/A6DqYPOHoKraxipT5FXhXDsGM6dZ4RAhQ6MSwIz0rqPstJwyA45A2w5xLBgY9Z3/EAYurvXsAzweOOaCxW/qVbAzjWvneLC0QBZ6UgtRLSGwAQ3q0uCQkHQPgvf4AjlkPj514MwAmfX9MGZA5XDKteVZoxqL9ToCxwR45JhgYndDHG/3HUPgRZ9so/kMv9rgpAAZjLGeMvR7AHQC+AsArqc0cn/0/GWNvZIy98cSJEzdjOq2HWLj2o36tGd8sm0ktfx2AoTI15ILeVbAUPEYVaN9xvSUMjMKmgdctuhdmYKieDy0W9G1TB8TcNbr2IiaeXljLwFDZDDJdpKb4bA0G5Ho3F2gHRgG8SI/9GB482gND+HaEneb7z5hzWqRk/CigJ8+IebfxSWnjwSL2r90jCzAwinLB21pCUjIwDmY2MCE+J2JUgWYAYzkuGRjEO0FNsmkq8FVJWaMHxoIgohgqGNAJOrWRpKL4HcbDWtkL0I6BIYAmee+3YPEA5fvAq94HYn61c25p4gm0AzBM1lSjiacCULb2wFCkUHU+NyIlB0Dj3yxxvuqu4e1x84YozM+s9JDmrKHwrF8cq11GUYRQndExITtwmX3OCDNHl8xjSiy4xRgkO7iONaTRMhDEwOiaZBRoBqEOeYrLA8PVfSYZGAfPwwPD88VJzMtIYRVkWCUMGkNCYsEYw8Ek1YAA4afxNDuDWb+MhTy6IgEqtwfGFvb8VW6kOaiKa1WOIyMiKQAj1aMq6wwEpcmrMm/q+EQxaia4yLHzOHIEeL44ASydKo+DewNcO5ryLnTI40anKeG5kOaYpYWebEMAKYDi2zHUjUcBO0rS6YExug4PBa6xjQrAGG3JTrFaaFXxmvY1b8vAOPTX+LEoAIZ45s6v9XBQ623B/QPOrPD3sIvBoha3LhPNA+W9AXCgoRUDQ7w7HBIS03jXFYE7a5CQBONruMbW+P1nJLZwNkHkTAsBqtjpEwoDgwKBqXeHm4FR74Hhj65ijw0x97q8EC/ve5G2s6GkkFDnep7l6CryFHEN504PDDNGlQYWAFsOBQDB/tN4hp3GVrdkhZXSjcNpjS8PKg8MymdGfa8O4xBJVmjn8YgABjthgC/3H8Ph2muBM68DtqsI6xd73NQUEsbYAYAPAXgTgFXP88RR3wHgiutzX6wxSSeI/RiRH2Gls4JxOpbFgTpEZCIALMU8HrVgxENuGKcB9R1wuYhuoPiSHhgNRd6iHhhqHGkbQ1Fh4gm4i6eCFcjY4gwMQXOvKxbyIkfBioUNMTUAJigjKGsYGJ2wI7vndXKM1t3fItH8HoDma6mmkIgox6boV3H/1RXM6pzrjs+SkLSg0avbLyIh6UXtjQ8BhZ1Sml8C9PkUDIxBNEDohyQDQ3xOlZBQBaLKyBIABlUgqulF/agPD56z4DSvxySbkO8YQE//aPs+AGwwwHVNptm0kmNE7uJ3EQmJyhoB2gNVJiMLoAt7bc4tTTyB9gwM7d5vAOPU57stA0Pcx03Rw8KjBeB/i+o8MFRAp4287vb4woYw7BMFC6XhFvGq64MYcc3iWKUFB76H0GHuZ/smBE53+EmaycJGDKrYzAsOvriKlUGygy22ioyhNKvckQWklUJCFCvHxKJYbN/axHOfx2c+x05h1j/Lf3Z4iVxwi0FJLMYJN2RcVcGUPe6n8WxxGrNolYM0x1fk9XWmkIyuY99fKyUkAsDY0Qz86jwwhG+KKIrquucH0wSB72mSHcoEVVxbykMEALDzBHbic0hYwK8lAByXhozH3AcA4J4KVEe8ipKsB1KACuBTzTNdLAmnhESwQ9g65t3NchLXpTyDilG1zQsLZAVrBWAcB6v8WAgGxvn1PtKcOYEJcT2FnMmVGqIWty4PigOLgUE/56KDLhgYnRoZEt/eADBuMIXEP76KLSbu/U1NQiKK8ciRFgLo4FZfAhiE0e3MZkFVKSQ0+8jlgYGjq9jCujJn7osmEmM21RQSBwNDZTBIgKYg3qe5beLpSuBhjGGa2nI/b/8ZPMdOYT88wRkjhzwNygShzBE4mB7zTAdVZAy38pxLCYnyPu16c7zWexo7628ATtwLbD8OEMy5F2PcjBSSE57nrZb/3QPwDQAeAfBBAN9dbvbfAngnvYcv3hinY7nwlgULsSBUAYzleBkMjFwQyoJFoYy7zDnVjusiDIy2XXt1IV1HF9ckJC3o6KKgEIkRgBvAUCNXgdKgsYV3Qptup+oDADR3rc05hX5Ye7w3KsdoKhY0toHwbGg4J2oKiZgTaS5JpJC0ZWAAiwEYTTR6bfsWJp6LMmnMufm+XyuBOk6PMYyH8DwPa501kllheuIANIDRloGhgmC+59dKxdRUIhFn7Lz388XfBwBnQYhrIkw8XXIMKT+I3fKDRUw8F5UhyTkbrBHAbbqrFuyTbCKfG2veRfvnVcxdBYPbmBYDHIyb5TPnPNShsqzq3qsmA8P1TlI9MJpSlG6PmzOkhGTV3XEV6SRrCgODKkSOZ3q8YRzS2vSRYSTnKkAA2tciCnyLJTEzmADm6M23scXW+PeUdHFR4KifcUW0jo0usRiu1BIRo6qNg+cAAJfYCcyiNSDoAIcv4GiWIg58stCKiP2bRnwAgN2nkAcdXMU60hzA0hng6IoFFmkjz4DJLg590YXeKL9gu70HRpKhG1VxsVGNCeXBJMVqL9KSB8LAlm40emDsPomd7p38O6Iu0F2Vnej9CY+SBLishTQnJK574EiToRgsTnq7iFE1u+elOeQ1to5ppwIwpkbhDlQUfbOwlde8SUIy3sZxUBblJAODv4f3xw5vi3JO4hxS0gJpslreH9zE095u32BgdCP6fSDkY+LZqktiyfICs7TQnsPQ8cxO0hxR4DnvI2/EfUmyvHwnzI+AlP+dlgBGjaGoZE4NOFMjDnwSwJD+OUpBHTtMPMV71QneHV/BFtb5vdffACYCwOA1kWAfASCviWq+ClSGtGlGz8N89/q+B9+jpR0ANHAEeQYcPI9L3mnMWcjfSaWB7SSxzZnVETqeMZOBMYi5OWf61IeAco0pZXPKMzvcfRCxl+PayuuBzXuAbAocf3H4CTeDgXEGwAc9z3sQwCcBvJcx9i4APwHgn3ue9ySADQD/1034rps6VGBCUMapJJJZNtMADMDRcVXSCZqKXq3j2sDAUFkSkR8h9MKFvCRuagoJIYFoAhkWYWCY3gkuzbuaxAA0g0BitPVMmGf8+vieX+tfkBUZcpa3ZmCkeSqLp9aRpEoKCeA2YNRkL3ED6FK0BzDI4rMGdFlEcsIYQ1ZkWvTkjZp4hj5PcKA+P07HUsax1l3D/qyegSGec8rE00whAeoBjLZ+EvJ6xO0AJVVSdiMmngBI/xWRnALUyw8oBobr+Kh7qJVvByEhocBY8bwCqAxsHUwyzUC5BfBpgqqLyKGA9vIegD8zdc/jNJ3K99ZyvOxkYJgSkmk2JdmFt8fNG4LWLzqudVp2zsBwd/cmSSa14EBJLScW/qOZycBwS0imhIQkDGxfiErvThR48xGibMwZGIpZpTSgVD7jAiSmCV84i+JVjCigj5FLSIy5HF5C4UXYwiqSggEr54CjyyT1WoyAKPCrQlnZ/97TmA7vBEM5n+WzwNFVSWkni4XJDgCGQ4uBYQIYbgYG77rqJqgATTE/mKSafIRvb0twKg8MImIxz4C9p7HXvVB9x/CUBmCIgnkQ2wkFQNUl14pghwfGkRINLLcN6O7wLGtmYMyiElQYbcl5qEWiq3ifSLCjDQNjjctbKABjna/fXOks4pkQ59Bl7siPk5+HOKRlVDQDgwIHRQqJAWAQ18NkawA0yAfwZ9bFvkA6hTc7wDVm3PuTHczSHEleYLkbVUCDQzLneVzGAPD3CCUhEddOZ9rQZq3i2XZ5YAgGRpoXJYDBWSPCA0MHmSnGvX5OXGkoM+odI+bu2z5BpHfH4QtAkeEyTvP9r14ADl4AYwyTJHOCzUCVQkIxkTQTz6jA78VvweaffDfwpz8MAKQ0q3/l4yiYh6vLr1OMf6vUmRdz3IwUkgcZY/cxxr6UMfYaxti/Kn/+NGPsKxhjdzPGvocxVm/Xe4vGznQH3/Vn34X3PPMe63fTTFkM1qQJmBISoL4z2w26jR1wtZAdhAMkRSI7q+ZQmQye56EXNS/+NQAj6CIrMnIBq+rYu0EXvufXJ1IoXdymBbo4nkUo1WmRahISBkYW6yYlvSkKVAzJZvDDqmNPFDoiiQFArVGjCi4B7SJxzQKnEdRRUkgAfj3J5BSl4y+683UJEqoHC3DzGBiLSEhUeRSweIyqkFnU3WN5kXMAo5TVNDEw+lEf3bCLTtBxvg+AFgCGMPUtpUpNYIBZgDdF4EZBFU/c5pzlRV6BYA6fBcaYdu/Xde9VE08RudoIuizoD6EyMGolX7meQgLQ7Le8yDlgpjAwWqWQBBUDozF1qSXAqw41HUlcf+p9pjEwShPPNiwawM0GvD1uzjiapehFgVxcU8wK1XyxbnFsmmi6GBhS866Y9rkYGLSJp729KKrIhX9Z3G6xVb6QHpwAxrtkzGLo8NeYEGkoYi5Up5iMUT28hFn/FAcZsoIvpA8vlcwVWg9OFQtVoazsf/dJzEtj0CQTAMZlpVgnioXyvBwFJQOjX7IDxtuYZRV9XBSWlInnxGDIhA4GAcAlJKtEiotZpAhAKKKu5cFzQJ5gr3tndd6XFABjnGC9X8/AGBv3H+A2bz2a8USOgQFyAbYHhlOycHQZedDFAYbIvIing4yuVwBGTAAYxlxqmTRiFDkw2cUoXOUFfW+1nNg+RvMcceBLM1KXkaeY03oJOlDmlXbyDP38moWky8TTfB9Io0jiHhLbDrXkIFr+UxerLEClLazz71HkU6pcTDzD1P18NMuw1Akl+2gQByQDgwJXI5eEJK+RkOQpMN7GjrdRMqYq2cvueI6VXoQ49BslJDoDg5aQTFPiHVOOgPAJkukpBqgKAFeCM3z7lfPAwfOYZwUKpj9/5hDPmEmsmac5usp74Z5L78R9/pOYrr8KeOiPgP1nMZ5n8D197p1LH8Ej7ALGwRJ/NwJabO6LOW6qB8b/H0c/7OOJ/SdwdXzV+h3FwHABE7KLWlPMaiaKLTwIbrQD3kY/btKeAdqsUtXTe57XLGfJdYo04JZAUAyMOn8NgNa8UwWAKSERdG1RCNTtH+AFr0gioeY/y2YaJR2gr7nahQYqBobL2ImSkLQxNgWgUemnuVtCopkZ1tD/VfkNcAsADKVz3pal0waco75LgDtUYSzuOXEdV7urJANDNfUF+DuBYmSpAIYAwqh7QwKaCpW/zhDTfB+0YTO0jScG+H1kvhPMcyVZPMr7bpTQ97PK3hLvjrYeGG0lJKapL+BgYCgFex37Tb7vlPSirMicBrZi7uq9L9JlqJEVmQbSAO39SYDKW8iDR15/0wMjZzm5fy1GtYENeHvcnMEjCUNpGkctevfGCfpxgG4UyAWqCWCYuniAL8Lr0gFEB9zVmQXoGNWIYGBI3wSKLl469W9hrSxWSgZGWRTqHUk69YMDGHbx6Np+Tpl4Hl5CMuCLZw4ycADjaGrHD4pBpWPIDrgocooc2H8WycrLAZTd1OWzwPFVjEsJBDV3YVp4FK5VcozOMjDe0aQ7ge/xqFsCwJgZoFVlvkd7IlgpLsTxiW43eS1Ls9L9/p0WAyMvGA6mqez4xw5mj5SQRDooQceocl8XVfYiWCZmgZ1QXWgAOLqCdHAagMcLxeFJYLylyJ5UJghdvAsGRb8OwJjsAqzAKColBmEHiPrA9KA0AA1khK2QhVm7KAGCtUHJwCAATdOs1OlBYRTBLqaVTCEpz4Pve/A8d5QsoJ8HV5RxXSqRiB/d8Tcs/5cqxSJ0MhSA6t4Qw8XAcEnVqKgt9vAAACAASURBVP0KM01SQnJ8DQCr5tzfBGYHQJ5hd5xgo7xmYSnzIBkYqW7i6WKYOA1pQTPgJCtMnXfp+XPVP4MkZ5yBcXQZkxlfrw2od1I5AocXzCwrKoNTxnDhyd/Fg8VFPPK1v8F/9tAfSVaYfGbnxwgvfxL/qXhV+W7Uk4te7PG3HsDohT1EfuQ07ZMARql5d1HGTQkJ1Zmd5TOEXojIjzCIBvDgkQULY0yL3mwyz7SYDC26l6T5HdG5VIsQgBeQbRkYC0tI2qSQFLk9b6JgMffd5Bsg969EkgJuCvksn1mgFVVQqF1ogBepDKz2nLQ9f2JQgACZnJIZc2no+KtdaMB9/8kECa9d8bkI4EGZOyZF0ghEiSGup+/58rvM6yk6z+I6rnZWaQaGIiEBeIebeh+oAIbYjnwfGBKS5XjZDWgWc4vxs5Aco0WRrLKbXIlDqgwJ4PdGznLy+lkyrrgGwLjBOWdFZklISP8XI/oVoAE5833XBBaJuZusCiejKCcYVi3BJQDSX8j1XtJiVBvkjG3Ox+1x84Zwg69jVuyPE1n4iAWvydQwdfGAKCBpd3ugWuy60gnygmGeFbaExLdZD+L/h5TsoCxWZOJAfxPIpshm/PnRJSQ0o2KaZmQxFDq6z6SJ5+ElpMM75O+xcgcHGaYzJ4BBmVyK8ycX8ocvAHmCbO0igLIoWjoLZDOwyR4AFwODAxgjITkAgMEm2Hjbopr344A0eDWZKUGNB8Z4nmm0bn58NuNFgFGkd0GZYnDQf1n1HcNTwPF1HE0SMFYV3+6C2ZbVBA4ZwhEh73ElJKR5Ac+rusfVTi4jLVNnsrzgAIZDQhI4iveKgVHjgVECUuNovTo3vTUFwAirRBmHiacottdqJCSmWWkcBmRiiGBAiEKyE9EmnpMkg2d0zCNCWsTnLeQYOmhG3W9msa6Nsnjd9jb4NelX/i+VuW8kmRKkB0aZVCJGk+dKzwDMgAVjVMv32K6/gTxn1ZynexqY4nme01jVjEaNQtqUsxbAIJ4VmoHxDBB2cRSUPiOr5wGWY7bLjTyd4BLqPTDkNd1+DP3DJ/D2/Gtx1DkN3PHlwGPv4awwdd+P/jm8fI5351/B76nuChANbjMwbtXwPA+rnVVnIdIGwFAXjU2ad7Fo9D3f6Yegsh4AZRHtkpsUKUIvlEVaGyAgY+0W/pJBoHQk23pgiCKnEcBQOpJt/B5UCYlr/1bh28AiMOckO/YhzQqZZ3MtiQFokJAswKaRzIcbSCEB3MWfBFPKeS9FS7UyBLOIc91TJv2/CcBQExWAegaGLIIDvehrKyMxJSSUlEh0nsVxrnXXcDg/tMwVVQkJwN8JrvdG4AXy+JbipVp2TttIUvUZBFowstTnqqV8Sj1P1HeYrJEm8E6wL4B6Q0wT7GgrFTKlcOJ7XXMBKg8R6t53Pq8OeUVe5GBgrWQhjDGaYdUSXAKgAUzU51QGRq1PSz7T7juAfn/dHjdvHM14V7wuem9vkmBdFIURDXRUtHKFtlvTmY0DX+rA48AFdNBGcjz5g2ZgiA62NgQDg61ysz9F727un9o34JaQuLwT5qYHRp4BR1eQLfHu3zwvuAcGKxBPt5yRgpTJ5dz0WtjlCST5KmdgSAkJgGB0FXHg02DAeAsAMArXqoJkcAJstA3G9OKl6yg+TZ8BV2EGcP+CQce+li4TT7ILvfsE0FtH2lnVAYxsiv1DDtaIe5VLG2okEAaln46GtOMeZRKDFf/KEAW+xtYAABxdQT4sAYyCScaI6NZbMcFE8d7KA2PEr+ckWq8AkN6aTCEZdkIpvaD8TNTvEeeQknzMjPPnkpCY/jUCUDKZkZMkR18BOgBxX9SATwZrhQIdSRBRjBLA2LUYGNu6hKSOgTHLLGPOOsZZT2N60eagtQBGOec9f6N8jwnQZceKVXZHyzokJA4Ag5LgBJSsjWJg7D0DrF1EEIaVBwaAbI+bGdcyMBxA6FxlYDxyPwDgL/I38vne/Y3A5U8jmO5W8y4K4GO/CrZ2EZ9mr+DnxPOkxO6LMf7WAxgAL0QOZnbHVQUwRJHqoozLLmrH3fVStwPgTB2wfBOE5tmx0FU12EA7ICDNU63gBOgCNckTePCqwqZBQqIa2gV+4EzEEHMA9KIlKzKn10fBCi0atQ4gsRgYDUW4GKoHhvick4FRfn/gB06ZgMnAaKT/5zcgITE8MFyF4jyfa4V1XZwkJSGpA9CAigEiYlRdMZ8mA6Mf9pEWKenBQklIgHZda/W7VEDKvH/FcYlO9GpnFQzMAiFNBoZLQiIYWWKRsBwv13vitEiDmOdz+by29cAQ16MtGJCzXLuHAPs+pRhFrrmo9xDA76M6zx9AB8Hm+bwxoUP1wGgrIZH+QzWMqbbsI8qQ1jWHnOlgx0IMjCKHB08e6yCyjZ2zIkNSJBpDCKDBdNOIFXDfT7fHzRki+lQyMIiCZV9ZHIsFvbk4porCOgq/pk92MDBc/g1x4Fsd6iq5gmBgjK4hDzo4wqDSjgPwSgd/rSPp2/sWc6EX8x5yys/FLJ5G1wCWoyjpy5KBAWA4u1ojIakrFnQAg23czfet0KSjyTW31ny0BYRdpOGgKt5LAAOAIQdyXMu0PQODy1L04wyISNyk7lruPAFs3iN9DxhjwNJpAMBk9xKAyoDS1YWWYIBmPurwwJhmBIDBr6tZYKc5kTxT5MDxVeRDDihluQAwtqSEyby/eZQvzcCoK/oEA2MarfMOPSABjHHCGRid0EfoeySbBqjYAkLqQ8sQ9GI1DmskHAYIxpjt+zDPcr1zD/q+AGj2DJf/2NumOaPvIYCzGTrLSIIBf947SzwVaLxNS0gcJp6qhMQlpZFsBkJqVZggWFbwCGpSCscZGPvhpu5ZM9nF4VSXZ7nYLjPjXFdACi0JoYCUiACXSAbG/jPA+kUu8SkYsHonAIDtcwCjzsQz8GwGRpoXyAtWvfcevR+z01+GLazxe/KebwDAcPHwE9V998ifAVcfgPc1P1H6CZXzXjn3n6+J538OY61Lm/apju6BH2ApXnJSwVWgw4PnNO0Ti2ixbRvZQZsCUiyggXYO/mrnUhb3BDAhihBRjDWZYVJzaWJgqHIN1zwAG1yQxSyxPWX+WLdvMdQUEsB9vCqbBnB32UVn2UpAqOmeL2ryZ8peXMwe1XxRzKWNhKRJwkRJQgA3jd7cvs6UUBS2AsxbJFUDsNkpFLgnzpVq4gnAkpVN0gk6QUfOu46BIc4B4L43TE+SJj8J08OhTkIS+9Uz2wbQBOh3gnmfmrIX2b0n/BNU1gNQAmsNQIAVIdzi3m8rIRHMo7rzZ0lIatga1LzFHOreSabJceuEGF9xBA8H1rkUx63GqAIO36Z82grQuT1u3jiapVjuhrUSktGs8mjouhgYhIFhx2HiadKYO2W30HzHuEwRKZaEWJiSTIPja0h7pwB4lQcGgHC6gzjQk0Wo1A8xF2rB7XueVYQAPMJQd+TnxTWWVQnJeQDASnLdklbI+RCRhWYKBHafAOIlhEunAJQF4jLv+Hen1zWvB22Mt4HBSQRBUBWAg014E14Iq/PnDIxmYMfzvJKVom/LGCuLaNuQ1QVGkR4YJYARqRTz4Un+uUPOtBFdcVdBKYpgjYHh8sCYpVo0MOD2wEjzwi6YR1tAkaFYEgyMUkKSTpDPjxH6dswnVZDXUfqrAysBjI4qIVmVJp6DDpf6DbuhG8BQ4oj581sjiWhiYBiRna4I5nlq+8VQ9wVQGbAOjEQPCsBI8joGxmVg6UzFoPI8zsKY7EoGxnI3kkayFJhyPNPBrU4YOJkogCEV8lwMg5y+7wHOwAg6GPvLpQdGycCY7FgABme1EebCaaHJasT9agJmSQ0LipJbWYBHUXAGxvrLeTS1BGw9eIdcQlIHYFAyLe0ZOHgeuPoA5nd/C4Dyvj1zH9DfxL2jj/F7M8+AD/zPwIl7gS/9Xj4PMe/lc7c9MG7lqNO8q4VInWmf2M73fGdhaBa9w6iBgdG2C6h07YF2HVdVQlInUVELWaA5VlBlYIi51DFHALTuSEoata93ian5uAqiNpGIoRdqxZ+LzaAWZ0sxHYHpoqTXFZ+iwAn9ELEft4rEBRQGhiPpRJWF1M3Z3FaYmTZdFxPAaLruZrFcJ6e6UQmJyU6h5FXivldNPAFYrCw14QHgAAYFaJrvDRcDw4pRLU0XST+JBU08VUZWU6ytGKohpus7BOhi+XE43mPq/TaIBk4pBuWBAbTzfzElJKaXj0hOMSUT5JxN+V7oBnfF91PzpvyEXO+kReNiARpYNSVOLkNpYTJqmXjelpDc0nE0zTQJCV3w5UrkKb0dZUjo0sab5nqia2d2y02zTzHqfBNoD4xrSPu8yM0UCUk027Nc9iNH55fH/tndb1f3N8kLGsBY5aAFl3lwlsRGse1czNeaeIqCaOdx4MQrEJXXJs0L3uX3fAzm193Gj6MtYHhCl8EMTsCb7sGHXvy5EiSomFuywMkKMGbLJSg9fRWjaiz1p/tc9rJxj2Lyx4AhZ2AURxzAEPdqHAQomF2cUaaKge9VrAVlHM8yS7ZR54Fhdc7LYo0tXyi3YcCA34v+eIf0AYiIJBxpEEqkQsgx2gKCGGm4VM2tZGBMk0wCWYM4xLEDwFAjZrtRQEtIMiOFxMU8ICQkgO2rQRneuuKMR9Lw0zBgJd4zHFByx5Fi+Yz+PaW575HGwKjxwDDMd52MszRHFOhAlQDBCmY/J85rfHwVWDqNMAj4vVoCscVoB0ezVEv4ccn35lneSkJS50NDvfPEcct30ugakE1LBkYJMIUdDhodPQ+gXg4VSJZT9T1z9Rl45F38h/d+G4Dynej7wN1fj9dOP4V+COBz/zcHd7/uXwJ+gCjwqnOyfJbPMW/nW3czx0sCwFjprFgABmPM6qRSHVdzcQxw6q4LwFD3N4yHzs4lYMsO6hb/GmjQoHnPi1yTYtQBAaqZqJhLrQeGMZeFjPtqGBVAxY4QC3kXzR2gY1SBdnIMlUHilJBk+jUX3XNzWJT7mghHgACAWvgXmCwDV9KJ2oUG3AAawK+7YD2IeSySQgK4i0+LgVFTUH4hRR/Az40HT/rDLMVLFpiwCANDfD/A3wezfGZ5LphSseWYfh+Iz0n2Vo0XgQokhj5PonC+DwhAc1ETT9c7QRjBWgk8jveYCn66mEHiuwHYsrYW/i+mJ47J/MmKDAUrKkZb2HemeFjv3rYMjKAZeDFlMosyMMz3kjl/y2TWYSgtrqHp23TbxPPWjaJgZYc5cnpbACj181WyA99OL2wonXccuDu45naAW5ZigQyBXdxkNQtuHF9F1ufshEyhXsfzXbugdsSiUoU6wBMTzEKWMWZLSA74oj1YLRkYeQF0hmDdVZzFrrOz7nseWeQASjG7/Tiw+Yqq2MoKIIiA4SkM59tasacNwcBQC5LBCXiswCpGGpvAJfOhoiojoiNOeRcAtAGjlAOZ3d+tR/i/J1+lm/yVDAyv9IAYKgwMwC4+x0lu+YKEguZujHlWWNfGJZNJMmZ3z8vrztbOl/Mt5HyjKQ1chcT9XeuNIA9sGxicQKgyakoAI0lzeb8MOzUMDMVQsxv5tImnwYxySXVMCUnls6O/EyivChcwOKEkJIGHgtlyDFLSI8bRFWD5nM7eKAGMysQzlJGuZoFfFAyjxPDAqJEsWSwyR9pMQqUXyTlfBZbPls9rZTyaHHHPGlPO4pL/UJ41poSkkuQRAEZgx9ZaMdZlhCrWX14y5sq5rF5AfMzB3DYmnup51+b06LuAk69CfPIeANXfCtz7rVhmh/jm+XuA9/08cOErJcgRhwowuMz9hzC65pzDrRovCQBjrcNN+9SCLy1S5Cy3AAxzMZgUCQpWaIUNVSQBdmHjMlF00ZjbyA6AZgaGTI0I9OLe5cqvFrJNEhJzoV2n61+UgWFKSOrAAFfnvimmNS1SnartkpDkNhhAXfNFUw3I7nkTjV6cFwXYoZJOzI74MB5ils9I7wmTYVIHXC3qN2ICUXX3nykhaVvYipGzXLuey51ljJKR5s8hAYyyGF/rcgCDZGAoz7mrQDSBT5EuYvo5TLMpPHiV2aeDyi/MH005Ru09ZIBgrTwwilwDwQBCQpJXUdBAPQNjns+1d8cwGrpZPIQfDrAYA0OcH5P9IKU65bvX8zynT4zpPyQYGI0eGKaMhWC8WGyNqB3LRHy26b0kAQyFgUHJGU0WTRzEiP34dozqLRyjJANjKBkYNDBRFIwDGF3BwBBeGXRXuxer3T2HHMOUkDjAE5eZY0h0qOsW3Di+jnzAAYw8Z0DcB6IBuskebRBKFU6p28TTBBiygoExo9g8eA7orSPq8XeTAGuK5Ttw1ttZCMDQGBjzY+D4CpdVhEaxtXQGy+mWu1DQGBjlZ8qu7oZ3pJ3Lbkhr6i2zUggGhn59JobsQAzKgFEUU1bxef1h/u+pV8kObVYwXqQHMYIJBzBEcSsBDEvulFm+IKFvF2X8+Owki5DoDgMOCUkJYPgrCgNjyO/FeL5N+qqEhB+HeDacBTnAr+dgUz//vTUgnwPZTN6Pw27oTCERkiDP8zgDo02MauCQTrR8zudZbt1DLiBxPOcAC2WIaQFhGaPfB0UOjK5LCYkK3vEY1Qz9OEAY+PB9j04CynIwpse5CimcOSiQT3gN2wa99vMkx/EVYOlMFd0cREBnBekxlw6ttGBgzAxZj+d5iGvfpzajjTofFsCmABgao2jtTvTGHMCo83PxPcFQqX4mwJ7l2WXguY8Cr/wOm9Vz77fhef8cvn/vV4B0AnzrW7k8CAaz6YsYpfqSADBWOivIWa4t4MwoRIAXIqaERCxUzW68S/OueWA4TBTFIrpt8Z3kiVX0TrIJqaUH7NjNOibDohIS0wOjlja+YEfS7NzXgQE3zMBgOgPDmUKimAIC7mvpMgV0FZ+UBKeNHAiAVXxS9H+zCAbaGTDWJUgscl3qtq+TApm+AYtISFTq/XK8DAamPZ+jZITAC6zEIZOBMU7HsqBVtzNZWSbTypXUISRlMqXDwcAwZQ1AM5tB3baNJ07BCjAweZ6jIEIn6DhNPE0GRhsJST/qk8wgMWfA9rdpI/kS970wDXZFv5rgXR0rRj6vDYwpynwUaCchif0YgRfckISEeg+L/WhyxtgGVk3pkjjO2yaet24cTfm15zGqdAqJ0JwvmUWhQ+6hdfcc2nRzQe9iYAjjPLMIiYjurFiYWhGW82MgOZYARqYU6r103wIOIkeigRXNVw6/hk6tAS87TwKbr7CK6nRwBmc9G0gRg5KQaMVCGSuKzS9REhOEzvss1vIdulAoCp7CQjAwAA5gqIkuHUc3nhswNnfPKeNM17apq1jfegTorPDOucrA8DxgeApR6d0hvsMFYIzL1At1UKALUPozGMcXEN1hgN9bVsF88DzQW0dQAleZkPcA6M530aNkSYHtx5FknE1gJZyo4+iyPDcaAwNANzuSz/igE0ophjkmyrPpkg1JE8/yvESh5/R+IBkYxn1kya3gBhJHc37tfNW3RjJi7P1aLB6ApxKxHFg5p1/3koExnqVShgTw948NghGMs5rUJQq4A2AZAM+znPbtYExjYFSSrw3kIxvAoOaS5QUy1QRTHp9nmZQ6ZVxomYy09zTgR8DyHXz/4p20egG92XWEsEFEdYhXjwreiu985dO/BXg+8Ibvh+97uleLH+BfhD+DD218H/CP/hw49Spt3nIeKwLAePGNPF8SAMZqh2veD2dVIWIaogE0A0MsVNtq3tssGs0Ft/AgWERCkrNcFj7msFIgavwhrCIk7CMpErJrL/atzmUhBkaDPMCcdzfoIvCC2sJXmj+2lB5kRRXTClSdTkqOYXXZa65l6xhVk/7fRkJCpJAAdIKECboAdvGZFRlylrcGrszr0kRJNzvRtV4mgoERLHYd5XexTMpHAJo1cZwcYxAN5IKlF/bQC3skA8NkZAF2MpHFwOjQTA0X0GEW1maUMdDwXBH3UBsgAIDls2C+c0TxqxoMe/BaSUhczCDAfl6bzG4BG3QRnzPPH1WwuxhFJmNKXJ8mMK4Ni8x833met1BcrMrAoK4/9TeLki9R58Mlgbs9bs44FABGL6ykIUZxITq1kpYf0NtRsXsR0akDKA8MujObOFgVonhRKeOiYLMW3EfcuZ+VSRUqXbyf7RMSEpuOnhcMSVbQKSSEiWcmwRQVwHgc2LzHAoCS4dmSgUEva33fg1nHzdIcnldei+3H+A83X2Hr2ZfPYSPfpT0wpnucQj08aXlgAMAGjhCHioSEYGAUBUOa27IJqsARkaF04oZLQmIU61ufB06+EvA8u2gdnkRnvoNBHMjfdQL6vpqmuZYIAdBASlEwsriOHB4YCdXxP3geWL0gfTO4hGkd8AIMkh0nq8eWkOT18hGApyosn9PPfwlg9PMj+fmlGgnJTJE7cA8M+vkVvwdK5kFOmPA6n3PbxJOSkFCeJJOE8CSRgJItxyBTSPZ4ag+XN/g6eJfNkCcj7bpoBbhybICdukRKaYgEIycDgzA0BQDMDrinxNKZkrVUfq6/CZRpSqoRMDUXS3omji90ewrRJp7uZCQ5990ngbU7gYAnuUiQaPVO+Chwxtt1grZAZXKqAhhZwfB9wQdx8dm3A2/87yQI0YuDSkIC4Mn8JN5//seAO96oH6cac1vGTH8xkkheUgCG6oNhdrOAioGh0s8FW8BcDLoADK1giZaQFIlcNIthLqKBcsFdQ2PW/ApammGKhbTv+c6OrtmJb2IyWB4YNZ1i5+K/yQOjLFg8z3Pu36VNb5KQmAyMQTQgiy5Xoof5h8W8loKuTc25YAUypgNAgk3TNGdAN/EE7K6xWVAKyYJZfDrvvwUZGC5TwIWYNDeYJiNGwQoNkKKSGcbpWBbMYqx2VkkPDDFXgJv6AjYDg5KKAcBRaoOfGnPLISExjWABt1ErwBkb6j3ses+oQxrBGjIFJwOjPD7R5ScTeAgTT6DBdFdExdb4gZhzVkEXypjWZI24thNzBqp7X7wbm+RTZqJOm3sZ4EyTNvcyZeKZFZl2TU0TT4AG06X3SlD9Lfqnr/2n+Pa7vr1xHrfHjY2jaem234t4dJ/vIcn14kIUOqIjGQY+uZ2ZTMC3pY34XJ1Zi4HhkBLI7rsqrxWggUXh55F9+cqd/F+lWFnK9oluZAkCKN1cyt9DnYvZRa3AlHIu0wNuPrl5TwUAlcc665/FqjfGwKPTsXzPNvqbpVzW4HkecPnTQDwENu5C4HvwPRXAOIMhxlj1iX2XfhEYnOAFSW4AGN6hBsB0IztRRhQDNgPDtwo+VyQuxdIhu79FAVz/vOyointAznt4Gv1kWytuY1NSUw4zicE5D3F8hEQGICQLVMf/8AUOYKif8QNgsIlBSjNvXCaezkQNgDON5oclq8AvZUxMAhi9/Eh+ftAJMJrRAAb3/ODbuWRDM8OUsjrPRpFvPee0iSfJwHDEGXM/Hh3AEPOgJD0kGLCrABgqA6NfpRP1Yv0+shhnFAOjJo3FycAg7jnyOh9wM1jJGhHnpr+BYMoBDN2U1v1cme/TKPAttktdqlNIJPZYMaqXPwuceZ081kRhYADAnf6O22AVkI07dVr9R/4Qvxj9JrZPfRXwjT8vf94NdbPZSZKRbLlYBVK6q0j8Ht71kU8553CrxksDwOjaAAYlIVnprKBghbaYFd0sE+hoKyEB2lPGaxkYhoQEaC/FkPt3mHguCmBoxVO81No7oSkpxEzbANzSBgqkoRIoqO/QqNqhPaesyJAVmeaBsRQvIWOZRR0XxYIJ6lDXUgI6wYISkpI1IqUILgZGNtd9OxwMDKpgHoSD1mkydb4IYr6AXfS57j9138IPpm1igunJItgQKmviOD2W50IMKpmIMvEEaAmJ1gWvYWCYjCzq2ChAaREPjDZggIzi9XQ2Qxs5hsvLhzLxBBqKe9MPpIYVQL3HKPme6fkg5lLHmFKfwUX8XyQjhTjXpl8GQKfiUMO8j2W0tnIuTRNPoAQwCI8WANq74O/f/ffx1Xd8deM8bo8bG4eKhASgY0+loZ3ptm96YBBFfuiIQjSN5KqiXi+WXJ14wcBQF/8usAP7zwIA2OrLtO0w2MRScUimYgC6uV5i6ruNuZidYvFZ4dOA63/D/z3xSqk5F/ucdDkzZDXZsvYN8E6kWeRkyaxibFz+FHD2Pl4Uw+wy8g7lCezZOx6X32cyMHprYJ7PJSSBzsAw5QSVlMUu8M0YVTXdQh1UMZRlKQCmy4G2H+UF+h1fzj9nFq3Dkxime9Z9CthyJ6pIpJIsrGhIua27YI5VAK0oKgaGNG2sGCPLuZ2Cw4+NliXVMjBEJ3n5DnneCgagrCOGxbEmIXExMFQPBpdsaJrqviB1sjLqObeKX4KBQbEeAA6omtKDKtbW9nEgi+S9p4Cgw89VYMun4vmewcDwLYkFaVrskpBQDIzyNiFBMJ+Yc/kew9pFY84biOb8+bZigV2+Fua59uskJLQHhglMS1lR6HOJztEl4NyXAQDiUJlLCWBcDLbtY1SGOD+S3ZanOPnRX8DHi3vxwFf9OhBXTbtu5GNafn9RMMxSmi2nxah6HvbDTQxm12vncSvGSwPAoBgY5WJQaLEBumChgI6leAnTbGrJLMzObB3VH4Blntk6RrWBZm92DcVc2hjxtQEZzGJ9mk1lsUHNQ3ZdW/hDmPMexHQhIn1EFqTSWx4ehIEq1cF0Fe1iHhZ9nbiWVIHTi5r9C9QkBrF/gLivijk6vg1gmAwMU/YCuM8zsLgHhuVrUXNPmV4mkR+hF/Za090tE0+CgTFKRhYDY627ZklIxtnYKg7NfQG0iSdgAwguTxIXgGEBmjUyJFO6AbivB9CegWFKSAB3mhLlowLQ7yXzeZXgWs2cTeYRQEshROqGabrrikc2j68N+0gFSl3gkumXAZQSsZYpJNR9rB4rycDof6tq0AAAIABJREFU2AwMaWqqgOm3x60dwgNDaKc7UWDR7YWEZEk1q6M6koQHhiuSdJbmmtmn6OBri/9P/CbufPQ3Adi0fEEvVgvIzMXA2H8WCLvwlkoTT9m53MRKcYiuAY6IwpgCMCg9feDZDAyLDfLCx/m/JaVZLXSOejyVZGXyjLVvgJCQvPsn8NMPfhPe7H+KMzuuPSSLeoAXiWlWeWAAwEZOFAultAZLZxCoBZEfII1XsYkjDQzqEKkGAnCyTVYpD4xSQkKYZ2rF0Pbj+OFPvBn/Ov4t3e/hhY/xfy+8qfycwYJYOo2l/AAr1avd6a0yT22fgcC3pUNVV9mQMNUVn+q9evAskM20hBj5PAxPYS3fc1L0bXlKAwPjqIzpLTv0fH6FZGCsemMthYQb+NKmpWI7Z4yqIcGRrCUiWllnZDkYMYSJJ+X9AnD/EtNHRZ5b63o4TDx3ngTWLwK+b8eoAuhQAEaLKN445KwHc94mkANwhkHgU/IzRkdB75fvh/WLOuDY30Q03wfAtKKdOn/inW0xMGokJIt4YAS+x6/xs3/NfyjARjX2evUCEq+DL/HrpRtWzOzVBxHO9/G27M0IokjbVr1PxTuKjifWJY27wQmcxm7tPG7FeMkCGC4TT0Dv3lIMDErLzhizO64OAzzZcQ2bO4YAbfyoHgO1PWADGG08MNq48pv7BRpo434l8wi8wHmcskts0OPb7Bso/Sya5BgFXfCq11IWcWFz8ekyEKQYGGSB0yIC05yzi1lhMjBcXW7BejCvexOjR5zrbtBF6IWtgSjBjiEp/QQbqY59YI68yDUPDAFCql3pcTomGRikiaciIRlEAwReoAGaIn7ZlJQBNtBhSsp6YY88bxSgVGe6aDIwmhgxAM3AoAp3U0IC1IOfpoknQIMS1D0UeMHCoAsl36MKdpfsRbw3TGCpLQOjzb6tiNu2Jp7Ke48C010MDJcHhnrv3R63dmyP+HOzOeT3FS9S9YJFUM1Nar7VjSe61YHDENOMVzRlFdh+HPgP/wKvfviX8OXeY9aCWyxuNQlJuaAOze7lwXPA6gU7qWBwAhEyrHj6fU7JU1zUawAIAg/mIXae+HP8YHA/Qq/cx/MfBzbu4d4HEJR0fv72h/cgZx5WDh+19g2UEhIx59kh8Ml/j4gl+Mn814HP/T9AkQH3fqvcXitGym7nZkZ0GUXBu3xWTyEBkHQ3SgaGCjJxcIsR58VmKNgdWreExGBgfOZt6ObH+K/99wGHl6qfP/l+zihZuwhAuQfEZ0u2yZ1h9ffRZeJZ62vBVACDZph4nkcyNhKzYL7+ef7vqVfLglUWfusvx7niCmLTdBZA4FH+Gg0Axu7T/N+1izqLSAAYGMn7txsFYMxmTIhjVrdzR3FWc7G8V8r/TnNmpIW4vSpsE0+7qAboOGPBdDKZUAnFwGAMuPIZ4Mzr+feoYFHJwOgb0h4ev2nczwKwjQkmCpGmRLFnAo8wsC2Y9tzJsfcM0FsHuiu65Ku/gYBlWMJUZ2A4ZEjqPPVtHT401DvPtyUn87TAqXACfPq3gb/834CV88C5N9r79wNc674c93rP2ceoDN8EqZ/7CADgk8W9FbOtHCqAIYBSFwNDvTbb3gZOsNsAxi0ZS/ESfM8nAQzTxBPQi586oENdOCZFAgambdfUATcX0XUUfpKB0ZLyD7i9KswualMxZMpZFkkK8TzP6R8CuI0Gqe6v2FYzomwrIVElB0SX3aWpB+hrGXiBJdchizimF3FAyxhVQx/vAo1cEian54LBAJpmUysKFLABCc/z6hkbzL6ObaVAgNtjhhrmuaGu53Fy3MjASPMUWZFpAIbneVjprGhFpDBAbcXAMABNz/PI4tflSeJK9EiKxDLSBex7Ux0uWRmVZBP5kQYKufwkTABjEX8I17lQhwBdmkyDXYBjHQOjLXOLZLM5wCUTpBH7bsvAoO5jFUyfpBOEfqi9f6lnhfqbdXvc2rE7SjCIA7nwpbrsI8MDA0BpykZ1nz2tax4RnXjGGBGvKBJQyvf4Ux+Qv/vm4JM2A0MUr8ocUhfleetRYPMVCs1cZyecYDva5r7avS6HABvIbrlnyCXGuzj57n+Cn45+Hxcv/xlnSTz9QeDur5ebqBKSMYvxBLsDw72HrX2LY5VF9dUHgCLDH2/8EJbYCPiPP8UL+pKqLY5fFB/Z8CzmLMKJ+Qv2jg8vA/0NIOrpKSQA5vE6NrxD7VxWMbvVsVrRiXLOtv6e8gwACLDjhU/gMDqJAh7w2d/jP5sdAU++D3jlt8tIRIuBsf5yAMDLvAqscQIYRMEsY1mVuVRxoVQRZ3ehU9M0cqsEME7cKz8jvVVO3IsBpjhp3H+ufVMsBW3sPsG9UJZO6x4d8QDMj7DqjSSzQlyDWUIDGOJ51NIdlJEoIAegMF1y+95oAjrEtpSExJVgRKVoALpvDWOsnKfxPji6zCNUy2dGA9BKBsYg27cYGCbYM3N4YAC0lw8NBNhSq7woEBGgFvae4qwRGLKrcs5r3rE2Z4ol4WJVUMeX5gV8r3rXatsT8+5Mr+OP/Z8E7v/vuYTk235ZOpWazIdL8V14BXuWg0mOId7DcpPrD2PeP4NtrFpJUz0FwKjzK4oNpsk7ut+JX9v8aeccbtV4SQAYvudjJdYLEcrEU5r2JbaERC1E6rr2VNFLmS0CsCMIW4IGTSaeJAMjdi/oVRDAVYyp+9YKUwcbQMwbaC5Aaue9QOHbRkLiKnjVe8Pl4g8QDIxMP3+1c87pOU/SiWYcaw6TXu7qdFtgVFSfekF1z6li62ZcRxfgIVNI/HbsA3OYEpJu2EXsx7qEJB3J6yfGamcVx+mxPDZxvVR6PmBHK0vpGcGssArJfKqdY4BO0aBYKEvRkjvRI9ffB3XPoBhtn615NrekB21NPOskJNS938S0oTxxKMYBBTgOoyFm+cyS+ZFsl4bEF0BnTS1FNKBDPSdtIm4BDvq1YWCogDvAz8c8n8vjAui/WbfHrR07ozk2l6pnoRMG1uJ7JgsRw6yuhd6ckhKkSQLGmFZAigIkEdKHaw8Bw1O4svEmfLX/oAVKUAwM0nQumfCF/6nXVB4EYj6r3NTzhMFO0OI5y+Eq1MVctELh2Q/z72E+XvXwW4EPvgXIE+BLv09uokpIZmmOB4q70L/+KSC3Ja2e51U06t0nAQCf6P89/Nrgh4Hz/wXwnb8qi3px/OLazHPgGXYa6/Pnrf3i8BKwcoc8ZvUYZp11bOBIO5ckgOHwiIgCu8CR9HWi0y4NJwFg7yk8uvSV+Iz3auCB3+cVzKd/i0sxlHNoAVIlgHGOXZXbyGQdomA2wYCQAK5cDAx+jAZIM9rGPxj/Dl4z/1z1s+c/Bmx+CdDhf2MiFaw5+UoAwB2Z3Yn2FVlSkie4/6n7gfRhfM/8T7inBjV2ngA27wG8ylxTRMwW3VWsYCSPQwCWUwKcmKdV2gll7ijOS6ycE+FRkxGAogp0SBYUycAgpEUUgJHlFqBEeZIUH/4lvC36X7GaGR32pz/E/z0v5A3KOyrqAfEQw+xQN/EM7DQlce5U0EA+I4bBcZIVpCyEP3f6z7Kc2aABY8D1h4GTpYGt+l4tjUc3cKQBOwEh33MxyeKAYhM5/EMgIof1fX/TpX+DdRwC//jdwE88C9zzjfJ35rPyXHwXljGqjTCVHhjivXB4CfMBZ1mZAEZX8WqRaViOdB/1nDxaXMClpdc553CrxksCwAD4gnB/VlHiXCaeQDMDQ1LGie0oCYkrBcJcRNcxKiiDt0VNPBdhYLg64CaY0kZCYprwNXktaDr9Bg8M7by0kGO4TB/V46Uo6S5mitmFBtznmjofy/EyGFgt8GJ6YER+xGN3Cfq/OucoiNAJOm4JE1F8UvNwFb83FYhqUSBSIy/0cwOUvgDls8kYw3FyLIEqMdY6nA4qCkSKng/AYmBQz7nneVju0FR+swtel6KhMWLiekNMM3IVaJfoocmnyvOksjzm+dwqfF3X2vT4qJOQpEWK0AstZofLuFidswnEzvO5ls5BAY6upJ4kTxB6ofVudILBBGuqUUKyoEQMsOOdSQDDMJkF6Nhg6nzcHrd27I7nUj4CcK2/5XOQ2j4AdPSl3WUU9Gz5rE72EP67+/C70b/WOqOVvKP87uMrwModuLT65XiFfxlxosvmpD6aMPHUCoWtR3hU6KlXy5/Lwnr1PABgI9fNMwMCwHBRr8X2ap117dLH8AfLK/iu9GcQJYfAJ34DePV3AefeILdRUw1maYEPFa9DMD8ELn3C3r8a07rzJBD2sIVNvK//LcAP/AVw59/Rto8VuvY8K/AMO421CUHXProMLN9RHoNeYMyidWx6OoDRNVkycIMSJqMDcBdPGmCUTIDJLnaCE3hP+F9y3f/nfg/48C8Bd32ddg6r61l5YMwQ43SuABiOjjglx7D2pxxrK+Dqnf8M/yB5O37syv8EPPAHQDrltPe7vk75DkVSdfJVyJiPl08eJPctrvlbPv4W/PRf/zQejt6Kr5r/DvCH/w3dud55gsuUoKak8O/KO6tY8cbymEV3mgIwVHYKVbgDtgmqS0IC6L4x4lpT8Z5tTFUB2wBYPV75/YeXEXzwF/A1wYP4+qfeUm3IGPCZ3+VgVykhCUwPlsEmlgubgWGehwnBwHCnKRWk/Mw3mQzjHXzN7ANYgvG39/gaj0o9/VoABuDY3wAAnA5HkrUAABHlo+Iy8aQkJJkdjyyGBUwfX8drDv8Sbw++lb+PfPvZUv1Rng442IirD5D7BxQJiQQwXsCsf1buTx1qjOq0ZBW1SfcZJ5nlp/JijJcMgLHaWW0055QJBg0Fi1w0pvWLRlfRKwpkk8LvKuyTPCE9MBZiYES0L4NZgDcBGBYDo442TnVda2jji0oPQj/UaLZ1hYj6HU0SkloPDBOMMlJcmuYMGMW6g9mhDpNlANjnUXiwUHOhZAKAbRoJuIEo3/O14rOOJUFR6V1GiYt4DFAjz2YIDNmLmjAyzabIWW4zMEpHcQFquhgYK50V7d5w0fOX4iUyhYQEMIzzJp4TUo7hYDaRHhgtDDG1Ln+8goxlWoFtghLqnFWgIy9yntRjeL8A7ntIve/FMbaRvZgeGIDBfiMAR5e0zQRsxbZNDIw24J1LDtXmXnZ585jsH4uB0SHYgOX5UE2Ib49bO3aOE2wMqvsqDmwPDEkFD/UFvZkkQHXsTM07+5s/gX90GV8d/A3OjT8vt7OSP46vAUtn8MLglXg0jjC//FFtv8LEU5M9zA/wP4ZvR3z/jwLbj/EfPl9+7ux9SpFT6d1nLMJGek3bN8XAqIpve1GsRRoC+ImtD+N/2VjBY5vP4LPf8PvAt/8bzpJQhiohmaY5/rp4LVgQA4/cT+5fTmX3CWDjbqQMNM0cemLCPMvxOLsDS9MXODggRlFwc9PSI8NkYEzidSx7E4RFBbjK7rKSSiHBLYLNQHXZfQ+Wvl8UI1nBpOfFXngSfxX9XWDlAvDOHwHAgG/5343zYoBenodn2FmcSZ615myZeGa5E0hJc4ZJOsGP/+WP4zc+/xYAGQlgaDT+2SHwxHvxB8G346n+fXzOf/ZjnDXyijcbnynPS28VH2Ovxqv3328xb4RsaJSMcP9T9+PvnrgPHZbj5zbPAlc/x/1A1HF8nXuayNhK/R5O4xWsYiyPQwAAQtajn5uKDUGlb/DzmaNDMCtUYEIWy6rUJNQZGPuzffzpE3+KhI0IDww6gnlGGGKK94zcvgQC78/fhDt3/4pL0ooCeP/PczPYN/0zTYqkPr9seBon2S6RQqLPher0uyRLWUFLSLQIZsaA3/tu/NTsl/HPL/8PgFr3XCtBrlOvAWCALgMOYJwM9fVLYHrLQPW10N8dLgkJZVoMcHBBMx999H74KPDe8GvJ7ePA1+Q9TwQXkSIEnvsoub34DqBM0ikK4OgKpn1uxGx5YISEBwZl4mmYT1N+Ki/GeOkAGF09NnGUjhB4gVZgdIIOukGXlBM0mXjWLaIpzXvoh5YsICkSuWBWR1roqQNiLi7vhDoPDFNTb9LAO0EHkR85F92WBwaR4qFuG3iBXoBES86ixcUcoajgZjKL2LaNB4ba6YyDGN2gq3cwaxgYFH3dYmC45BKOAofarzlnFdQBYEmisiIDA7O6rlQBRTEw6pJCMmZ/f53x4aIMIGAxaYE68msPIth9CsiqBeJGbwO7ZZ63AB9MAEMwMMQ7QRTxqgcGYJ9nl0HicrysAZqAnVYijs3liUN5y7jSP0gfmjYSEq9epjDPaAZGznLtfSONYBWQL/ZjhH5YCzia+13UeJRim5Dv6IgGdUzJnNjnOB2TfiOuZ7ZODmUyzqjEKnOYJp6hH2IYDS0zWvP+pADnWTZD6IUWYHR73LphSkjCMrowKzI8ffA08iLHLM3he/qiNwx8JFbHztabhwqz4vH9x/ENj/4avvfcGRx7Hu44qNgGVgf36Aoe6vbwS+N/j+85dwb/1Wf/Fd7xxDvk9maM6r/97L/Fb13/x9g+/WEUD/0R8NvfCuw9DTz2HuDkq4HV81ZRxwBcZptYT6qOPaB2r/l2s2yGv7j0Jwj6T5EMDL6Y5/+9PdnGZwr+jIUrn8HR5pcCX/aPODVdGbHiNTJLcxyjj+KubwT+5v8FDGDbUwwdrx5fxk8OgF32MVKbDnA6vziP87TAQ8XL4bOcy3LEOHwBSCfAycqbQWXKjCNuNtqdV+wU06fkI5c/gr+88ueAl5Axo1T3lzp/mpfFIffq2AlOIQ16wD/8Y+BNP8Jp6Rt36cdJxN0+xC7i7ORRyVCgCsp3Pf0uzHofQBAmUIcay/qOJ9+Bdz/7bvynrf+IaP0j8tjVoTEwLn8aAMNf4T783sW3AKdeDTz0duD8m4CLX6t8R1WUFwXD72bfgLX5ZeB9P0fu+4MvfBBJkeCHOhfwgwdH+FwX+PjKJmelqOPSJ/m/ZeqDKa9JO2vY8I7kdaqVkGSFZFtFhHklULKtlPQeE6i8OrqKX/ncLyIcPqwBRaHClChYgR/9wI/iZz/6s+iffxtiIg2IimCep4WVClO9ZyqvGOZH+Kn0n+C4dw740x8Bfuc7gL/+ZeC+fwi88QeUz+psgnz9Llz0ruiGmErhmxc53vbw2/DQwYcAGNI6R5xs6pCQ+Mo9lFx7CP8yeQ7fcvbleMq/Arzv56sNn/kwj309e588j/LclBKSk4H+t51KgHKa7hJMmzTPyAhVQICqyr4vfwZHwRouRS8jtxd/V8QYZRGejF9ZpZUQQ41RnR9dxi+sDfHb7BqseGXwd5PlgUEAE7Hh3TRPbenSizFeOgCGkTpwnBxjGA/1eCnYsXTTbMoXg0TR2SQ1Cf0QS9GS1kUD6KK3jsJvMjDEd7RNjRD7Z2DaZxhj1oLe8zxSZy62NyUYdfR1E3gB6rvrwkDSLAAAm21C7bsX9pzpKWKY8wfK4lM18czsJAaRoEKBARaAEQ6QFIlGcwdoRoorqlMdFANjpbOip+XkdvwlQMcsunwAADeTxuqe1zFpHABGWyZN2641AORHlxEAwKjq/m10N7Az5YZeYj+tGRiEhKTpOZdzntebeAL0eaM8SagYTTFMFkHohzx6ts5Pgv1/7J13nBRVuv6/FTpOzkPOUWAEQRQQRUTRNYNpzTmsXmVXxLBiZHUVwyZ3dc1hVcSACKIikkRQUMlxhoGZYXLu3BV+f1R3daoe8N7r3s/+ds8/IlRXnzrn1OnzPu/zPk/qnFgxzqwYGOmAjuQ+C4KQlkmWvIdBhMVzBBoYVoyp+M9ZrX2zNCyJFWPFwHDb3Ki6mqAjkdyH5L20M9yZAnhYXXs4TaH4z6aAlEnlS96wN30JSdJv1n/KR/55zR9SafaGKM2OL98TCal+rv3sWs5ZdA43fHED3pAfhywlinNa0LutMnbRg2YgrDD367m0amF22Wzcn9+L0paNCd9r3EOHsJ/GcAc3dv6ALojc2qBTptuZu24ur21/LeG+mq5T3VnNS1tfpEhR+TArk4cnXYauKfDy6XBgLQw/B0gFJhRNZ4/ek0J/eUKfk8tTnt70NAv2/wl377+zteGzlHGMz6JubTJAggspQZQ9VHq2plwPqRoYggDiqAuM34OkQ70Up4HxuNTBEr2dGtvLhCULYU6SNDAUjS1ahK5dsyl2UZShEhGXTAZ32pyGPoijrcL8SDToCYQ13tn1Djctv4k3yp/E3fc5WpNAIFkSEjKuAGooQJm0HzyJlq6mNomqQXs1ClAl2QyWTdEQmP47KB2R8pzJpT6KqrFZ7YdbaTd1IpIDyhUHV3DPmnvQ8hezxvMg9d76lPuFVZWFexYyomAEg7PHYi9YgyimapMk1NNXbwQEtmj90exZBuBy+Udw+YcJdHpZjGWiQ6rGZ9o4tnS/CL75M5R/FeuLYAS2n1V+Rom7hLLG/UzszMRGFm+X9oVdSwxx2GirXGMEuFEGRlI5TMBZTLHQmlJCYmWRGlRUbCJ8V/cdHVolIVVLTSAmiXgmA5D3rL2HTw9+gLPnm1R6Y5og0f0hrGp8tO8jtjRuYWRBGZL7ADXB71PGN7kMSdV0QqqWIuIZY3BFQIZDP/JBST/87kN8c8xToKtGucIZ8+HsPyfNSSLTI5Q7iCKhg1xiv9U2UTDf1/f2vMf8jfNZ0fIMw7JXJjJM0pUspSkhiWc+PbvhdyzKyuSQ5Ob2kmI2b37FYCjoOuz9AvocD3bjdzRBoNOeQViwUSgYv6VbGrewpGIJYpKTzdu73ua5nfciuSpT2CD2uNIKTdeYs3oOSz1XoeQssUyQxGu0ADTW/ciKzN6kqTjBJhmAZnRPDSoae11lBrMk0G75mXgb1QU732RBdhYLg5uR3OWpJSQ2KVUDw7KEJBGoiQfr/pnt3wbAyHfm0xJoMReRJ+xJcSaA1ENjQE2lgbtkFw7JkehqErYObLId2QnXQZqg15bevjSZMi6JEk7J+ZNKSKyoxmbWXkrN2lsF1Jb14IfRwEgGC45EAyM58IXUwDp5TKLX+sI+y40i2pKp2pAa5FsxMKwcKSBNRjcNlT6dJggcpoTEQuchx5GTsK6sgmBIZRDEX2tZFmU17xagz+GsJ1NKTtJk262YNFn2LIJq0JKNlNI3QNZ1CMbuXegqpDlgMDDSARgpDIywNQMj25FNZ7jTXJvpAIwceyKgFFbDKLpyZCUkFtaeVuBC/PUpY3YY3RArQUwre2krcDXddcBPKp9KATAOJ+Kpp/Y5HePALtoT3uso6JK89wbVYELpXrQfcBj3lKQSJ0VTUgCP/y7DCtIDq/Fryhv2pvxmWYoQq6nA2X/az9f2NxnrfUBRbG5skkijvJjvG75nxqAZfFv3LT963ksRzbN2IbHSwDAOmu/teYftzdt5pKWTGfberMiCtrhMeayMQIPOOp7PzSGgq5yUfS/5nQP5a10Dp/Y5lfkb5/NZ5WcJYMRXVV+h6hqv19aR3zqWD6q+5L6yaYQFAXoeC8fdDKRaX4YUjZ1aH3L9VQl07XhGQEughff3vM+pfo2RwSAv7XycBm+i6Gc0i6rrOruadyDqOue5RqJrMltbv7Ece0eCBobhqqANmsYedw7hLe8mXBvNdtZ4alhhF7jM3R9Jz6RWfsfyzBBf5x1UVBrIw5fRCz0qXggxd4zCwcZ3SIngTpPLADDsbfvMj0QDsAMd+3lq41NM6D6By/s9iCh3MPe763l317usq1lHVWdVqj5E1bfcse183uUeeHYE7P404fnACLZUTz3XlRbzhfg4XvdSy7GLNjmpzwFFY3MUrDn0fUKfowHlh3sWUqJLzKkFr1rLZZ9exrpDBo09Ou/bm7eyr20fMwfP5PiC8xBlD981xsAFs9/xQWTTHsjpRavmNt4BewYMmGIGnNFmi2NgROd/45BfE87uwUtrH+CqZVfx6PpH0YQAYd3L14e+Znrf6YgNO6gU+tJDPpGV4SYaCcOORcZNNdX486BpYHNGxjSxvMbvLCZf8OAUjN+m6PtsWUKiBvnO/weu+ewaFjfOQc7+0RzjyvZKZn01izrn3whJMTHReACjor2CTfWbmNH/GrRQEQsO/N5MzNgi/eoMdfDMpmcYUzyGp054Hi2czXZPIjgoR8okdF3nw70fct/a+9jetCvS/3QCrEY/Xwoc4EFnAHefF/lW6oBf74K79sOx1ycI3oLB3kgon8oxmD4lwQNx18Tm+sN9HzLYVULfUBip6BOUuARQMuPny4Nf8tA3D6HZD1iWkIgRG9UaTw3vtO/g/CCIdbNxiIX8prSUto9/ZZSVNe02gdjo85rgjiDQKeZSIHrY17qPq5Zdxd1r7mZP8CNzH9jSuIXHNjzG9rb1uPq8wJq6xHcrvkTmvd3vsXT/UrqpWYQyl/PC5uct+x3FJ9u8Dcy0t3F/fitt2X81WcTJ94eYS0xQUdmXMQZ0jdpdH3PX6rs488MzeX7z86YxgBBXQrLk0FoGhkK4BRe23G8tRTz9ZglJVwBGbG/UdT0tsPRzt38bAKPYXYyiKeaB1hvypgQ1YAQiyXaryUGIIAjkOfNoCbQkXAepgU18PX60dRX0WjIZ1J/GZLDKBJoOK/FZ1DRBSDoGhhXA4JJdiIKYtjzAKjj1hr2WrhthPRLgW2lsWAhRJt/bbXOndW4wn0FXsAmJn0tmYKQTwUsGDSC9iCekBkRW83KkGhjJwU0ymJIOwLBaf1YlJOky1pC+hMQqC53u+hxHDp3hzhSb1nQaItC1LWi0qUJkE4s7OBe6CvErfnxhnzmuySKe0aA8ysAwRTyTMtwFzoKE69KVkKTsB2p6pkby+rey9uwKUEoW8YTD64ZYvbtWrktWJSRWYIDVGoKuBWyt9oJkbY34ZsXIsnJcsWK6WD1btN/J10bfV0v3FCvQMU15ihWAccQMDF2xBCmTRTytALbk+/sVfwoo/a/WBEGYLgjCbkEQ9gmCcLfFvzsEQXg38u9mgXvsAAAgAElEQVQbBEHo+8/vpdGaN/yDwUIVw7rFzhMBoZIO+wouGHwBD054kLMHnE158FPsjsR1IEtCAk26yd/EfmUxvoxPeG37azy18Sku+uQinq+8Cnef53hu67OcUDqeMzpauSB3ApIu8XymZNgZEgtswqpOuL2aZRluphUcjVMoZYc4CJu/lceGX8+owlE8uv5RgqqxhjVNZ23NWvpJGRRpdjraL+BXR/+KxfXrub3sZNRrloEztofGB9YhRWOX3gsBHeq2sbp6Ndd+di3rGz8BjIB6dfVqQlqIa1vqubA+j7CuMPeLWxLefSnuoL2zYTP9wmFs7j6o3oH82LzWcp9I1sBw2gVuW3MXM0pyuKRpJS2+GEtBEAyngpWVXwBwSX4Z2cFf4BH2sqZmjeW940U8Ad7tNowJoe1MXXAySyqWwP5VBnjhNkpFkhkYnWIurXomcksMwLBJIqKjlj9uux+n7OTRiY8yKGs83spfUZrRk0c3PMqNy2/k7A/Ppk3cYAbqf/3hL4z58hrm5bm5X77dEJpcdKthjUpcOZCu83X7Xja5nNj1Qjqdn7KxLsbSSW5SkvOEP6SyW++NKthMtkl8QOkJeVh3aB3TOlo529/Iq7UNSKrCjV/cyO0rbkePBPefHvgIt+zm9H6nM1grwh3MYOn+d1PmMcqSANDbq2nJ7U5IVdM6Nxh9Tlx/AJLNzq979OJZWvEGO1i4ZyF7eBaP/WsUTeH0XlOgZT976E0/xxRUXWNxSV/47u+ghuG7F6GzFsoujs1VUkDvtUfsQUMGkOCySSCEqPXW0hZoo7ytnJVVK1l+YDlS9xeoCm7glqNvodQxBGe3Dyhv20+Tv4lrPruG9bXfIEtb2K49xJ++/yOrqlbREjwEGO/vx/s+RhIkTux2NoGaXxJQvdz65a18W/stnnAbiAG+bPoTnaFO7h1/L6omEG4fy37vJmo9tZE5VTmkfYk3+x9c89k1zF03l4/LP+bXq/4LxECqC0lcCYmma7wthxgt5qL6e/FR9dNUeWtAshZrNJg0sb2sM2cIAMXeXQn3D2saTf4mdjTv4DRFYlZrGwfsMi+uvIfytnKqOqoS1tv39d/z65W/ZuGehTh6/5XywHKa/E3c9uVtjHtzHE9vfBpJMtbvcz8+h6jr3OwegBJ2MT7z17RIMvfJHrQFlxtiu2W/jFtHiQByu5hNHh28s/sdZFFmbMlYtvneR5OaUDWVR9c/SpGriNnD3kD1DuBv2x/jvrX3medDW8ReNKSGeGHrC4zJ6suyg1s40+Plz5v/wqJ9i5LWcey9W7TjTVokiaODAwnJe5m5eCY7m3cmXJ9cYhRUNKqzRvF1dgEzNj/NyqqVFDgL+POPf2be+nnoum6WkLQGa9nuOcg5nV7GZI5FztpBSEuMlVw2CVXTCatalyUktrh913QY+g8D4+drhS5j42n0Gz9oneHOlMNg9Lpo9hYMZoVVNivPkZfgamJlrwgR8dDA4UtIogfu5ABS0zUj6Ba7Drrjm6XbhUVGN13Qm+WwpvBbHdC7oo1blpBESlmsgpxowGIlZpf8rOkyutC1mGGyJWn0O+LHPd245DnyUtkMaWxUwbrsBX56gJOs2wGporRWlH5IDYLAGrj6yQyMSBY6pIWO6Hor6j+kD2yha02HaNMQkNAhbvwKXAbo0ORvMp8nGcCwSTYybZlmUB4d/+QMd/y9IP17nufMozMUs2WNMrKs9CSSXWeswAArwDH+eitAs0s9CQswwMp1yaqEJAr2HNHekab8Jx0Im6ytEd8snVOsRHfVQErAblX2ku750gGOkJ6BAanvrAlQxpVbdQUMxjcrZlhKCYnitbRRhURwyQrQ+VdqgiBIwF+A04HhwCWCIAxPuuxaoFXX9YHAM8Dv/7m9NFow4GXX/meYVvokWxs+ojPUSUeog3JeRNSyueOYOwC45ehb0NFQcxKzo/EinnXeOmYuOp8qFuJ1fMr8jfN5a+dbuGQX/TKMmu2Te57GY4MvRwDsWQPJaxnBFxluFm+NlIRIMQr4N4e+pl2SOKP3VMKqxk7RYAnY67bw2+N+S1uwje9algDgDfvZWLeRSSGdQ67BSJKdm8pu4t7x97KmZg3v7n7Xot8RXQBVY6M2BB2BRVte4tYvb+XHhh/54OCfEF0HTACjWHIxLBTmYd8dzPKJfN2+h7d3vW3eM549sqN1N0NDYQL2AhTPcBoDtext25sy/oklJBpy1vesqVnDjILR7JdE7ltxhwkWS6JBo/7q4AoGhEL0zumL0z8BJyU89M1D7GjekXDv+Hr2YFhDtNfzB3UPA0JhSnWJu9fczbKGjTDwFPMzUpLFrKLp7NZ7IdUbJTCqpvJOxdO4+/2RtmATT574JEXuIoJhDT1cwJ9PfJVF5yzildNeYVTRKPbzKgHq2dq4lb9ueZ7e4TBLMkWWFh1EPeMJ8DXRsm0BTf6mGACkwWJPOTmazjB9LrJewNx1cxPOqwnPmaxVElYJI9OaOxyqvjXnG4zM7+rq1YR0lVPspZwafII+ZPNxTQO3l/2KFVUr+Lj6DwiSh7W1y/lF/1/g1jROWXcZd3RWsadjN1vqE0scxLjSoadCNZwoHsLW50m2+xbyyrZXeG37a+xv35+y/sJqYgC127OKlYFDzG5u5b2BV/D4CY/TwR463R8xpngMR2kSoLNb60G+vQeji0ezKCcPvW4rzB8En94F/afA0DPj5jNRA8NjLwLAFWjgm0PfMG/Tb8gc8gBP7LicE949gXMXncttK25j1spZSM5aTin4DTeX3cwvSmeDLjFn9Z3c9uVteMIeXut7Icuqq5jq9fLC1r9z64pbuee7y5FzNhIIh1lcsZiJPSbiFnPRgqVcP/QBDnYc5NrPr+XkhSeRNeRBDgS+Zfa42QzJH0JQ0Qi3jQUM7REwyra2BV9BdW6n3lfPXePu4o3T36DeV8e1xffSv2UtFW0V/HLJL5m9ajY64cjzamyp20iTJHK6eyj+mksQBZG7Vt2VlhmbUI4BdNhLqNSKKG9dyTObnmH5geWm/W2UrTOppZ58aRwTfAp/qVvFuYvO5YwPz+D9yucAjdZgO3PWzKFHZg8+OfczVO9A1rb9jSkLprC+dj2ji0fzyvZXCLlX0q4eYHH5Yn7Z6aW06CgUTafI3p87x81mtdvJvcMnEbxsocmuifY5Xh+kjWyy9XZWHFzBpB6T+P3k3yMKElLhp7y18y12tuxk9rjZuKVC/FVXcdHAq1hasZQZH89gS+MWswzuo30f0eBr4EY1E6+YxYzW7hwXVHlg3QOsrl6dsL6iZW1fVK9iWDDEUeFT6emfgyRIzFo5K4HpmVAmhrEvdYqV3FqQSWk4xPtnLuDV6a9yzYhrWLBnATMXz+Tv255DkDrZ5VkJwKk+H8MzJyCIChsbvk6YQ2ecq44nGEByVdAeTnSXAmPfTQZ3/6OB8TO2YncxYIhDgREcRTNp8a3QVWgGK2Acaq2Ajnxn/mFtWcE6a28VgJgH7qSMYfQAbcWS+EkAhoWqfbogJNtmfW+rLG703ukAj58SnFpmidMEIlbgyJEEC5bBdXIJSZose44jJ0FHBX4aA8PKhSSd0Gt8S6eBEVSDZl+j6y95reY6cvEpvoQfHSuwwyk7cUgOawaGlgqgdaV9YjXG6ebRUhvhJzAwFAFkHVBim3yh0wAr4wEMK7ZVvC5O9LmTr4syMJI1NZKBjnynkYFrCxjvuukEYcHAiL8PWNsq2yQbbtmdsh+omoqqq//tEpLDamAoqWBAVyUkliVLoSMrezkc4Ggl4mm1jqw0H5yyM0WQGazL947EQtjKOShdKVACwyryG5Ms8JrcLFlWcWxAXdfxhlJFPGVRJteRm8D+CSiBFKDjX6wdC+zTdb1C1/UQ8A5wTtI15wCvRf68EJgqJAta/ROaw5nBu6U9eSPHxW83/p4pC6Zw+vun46eejI5Lzd/dHpk9KOFkgs717G4xdBPW1qylXlxCQG8iqAa546s7CIQ8LKyp5YfKKtYNuJp1l6zj1emvMqPXnfgO3MIdZXPJiWgfeFw9aWk6jXH+AHP3/oNP93+aQEH/tP47slWVCf1OJazoVEl9wOaGmk0MKxjGxO4T+brhIxAUtjZ/T0gLMam1jhrHAFNE9OIhFzO+dDx/2/y3hD1LiishCSoaLWTzTvEQ7m/6huO6HcfnMz8ny5aHo+gL/EqQdYfWMVl30pHRlxay+cXIW5jk8/P4t49z6dJLOevDs9jcYQRdTb4WGoKtDAuGCNiyUTqHYRPtvLrt1ZTxj7dR9YdV1IwN9M3uywMnPMadLa2sbd7CO7veMfosCKj42NS0hRN9fnDlo2gCR8m3omgKF31yEQ+ue9AEexOzjCpyzvcgCPzR1pdXK3ZxNE7m5mdT1X+y2Z8U1wpV43ttENRtRg/5eGT9I6yqW0y4ZQIPjH6T47odB8TKIJw2if65/RlbOpYnJj+BgERbxls8sv4RCkU7bzZ56Mf5hJybuKfyI37frTdTt/+BUxeeykG/YaXYHupgRbiJ0xUbguamJHgVDb4GLllyCd8ngQfRuTT6nFj73lY0lh+btvLBrnfoCBn7i6rqLD/wBUWqxvDiY6mjgHXD52LvqOY6LYOby27m+5bluPo8T1gLc9mwy2Dnx7hDTQTajiFD0/jH+sep6qji6mVX818r/gtRCKNpOrubd/KaC453lKCrDn70vMvTm55m/sb5zPh4BssPLI+Nc5xgpDFHOt+0vMfQvCFc7gnAoR+Y3m86Q6XrsAdH8cDxDxiOPECVko/DJnLOgHOoCDSy7fSHYdCpcMqD+C94lZXVq6horzC/J34+O22FHJIlfrP799zwxQ1UdOwh1HwipxXfypxxc/jdpN/xjzP+wYvT3sSz926OyjHWRr6zmEDt+VR07GNHyw7mTZrH4JqthLVsftfs4/O8E3jzjDc5Km80zm4fsujgCzT4Gjh/4PlmoHhM0SQ+m/kZf5n6F+aMm4PSNJ1T8x7l0mGXAgbI0i2sMdQ9jPf3vs/SiqW8vuN1+jtOhYMPsPT8pVw+/HKOzuzNmR4fi3Jkum2/j1+v+C92texiWeUyFla8EFm3OsvLl2DTdUZnjUQP5/PL/neyrXkbT3z3hCUbSk6yEK7prOXmHjncL1fz8raXmbVyFjXal6iaztrqtRQ4CxjafJA6W2/ObB7C71t9zJvwCDMHz2RZ1QJcvV/kuZ130+Rv4onJT5DvKMJfdSUT867kl0N/yYKzFvD8tOeZ2nsq3oxFbFOeJdPm5trWVigchKLqyJLIJUMv4fYxt7PEf5Crv3skQa8l2TWolWxq5U4a/Y2c3Ptkit3FHJ11PrbsrTy58Ukm95zMaX1Po1/5G6x3/Be/svfm7TPfxi7ZuWrZVdSoywkKB/nb5r8xqmgUx1dvY6ejjMUZF/Fs7SGGuIq546s7uPXLWzn9/dPZGfwHqq7R7G9mS0cFU3w+6oUCMoXePDrpUWo8NXyw9wOzf7YkLZqgorI7/A+K7Tm8eqiGXvV7EASBO8bcwcMTHsYtu3l9xyu4+z/Lhra3Ge/qTndFpTRjNFo4m7W1sXcKwBlhW9R01PNW1SzcfV/ggiVn8dbORLHbeLZNV9bYP3f7twEwkhkYnrDHzKTFtwJXAd6w1wwIPWGPZfCT58xLCGZNAMOWGvQmH+gDagCHeHihPLAWfoRI0J0mUD9SICBdCUlXWVTLviTVakdbuhISSB/4Jt+/KwAj+d7paOMJ36GGkEOJGd+UEpI0gphWbJqfEhBZBTiyKJNhy+haxFNTLUsyINVFw4oBFH8dpJ/3roLP5OCqK+eLrhgYVkyadOVUR8LAUKMMjDgAI5410exvRhIkc7ziW54zzwQc2kPtZNoyU/od3TeiAEY02E7eE6IARjSQNPcDKXU/AOv5OJJ33AoEgyMoIYmKeMZRPB2SA5fsSixTUHwpZTQ/aQ1ZMH6i/f6pAEa6kjWn5EwAj63KXsBaf6grBkZXNr+WTihJAFs6FxL474l4FrgKaAu2EdbChLQQiq6kBdOTyxn/lRkYQA8gXlmxOvJ3ltfouq4A7UBB8o0EQbhBEISNgiBsbGxsTP7n/5X28QWL+dGfwz/ozvmDzmdyz8kc6/gtQmBwwnXF6lmIuLl7zd3cveZubl5+Mwf196nPfpQrPr2C7c3bmafm4NB6UWkbSNaOxeY8yvHU4U6DHu5xlNCm5/NUh06ZlMmc1XP4uMI47PrDAVZ4ypnmD2LLKCasaog2GbodHRFKhCuOuoJOpRU5ezMbG9bgll0c42mjSS41qeSCIDBr7Cxag628vuN181nia8dDqoYgt/NURogxgQB/7HUmBa4Cpna/ADljHx9XvoE37OXk9laaMw2xS23EhTzV6uMSezdkQUZHZ33bm4j2Bna0GEyIYaEQfikHXc3izD4XsrhiMbcsv4VVVavMACq+hKQ9fIiwvZxzBp6DkNODi21FTBIyeXrT01S0VyAIAppzF4qucpLPD648VE0nV+rD4vMWc8XwK3h/7/u8vO1l897hOH0NW/ZWRhaMI//8F7Hl9OTJ6gPIkoP7K96NY3nEaZAAYU1nM0MQNIU/rJ3L+3vf59y+VxJsOAu7EDt/lhxawfHi9oQgoCSjhIHyRYRt+9jZspO7wy4yS0ZSqJ9JTvAMllUu400n/MIXpltGNz459AwIYVZXLyeEztmS8XyZ+iBeOu0lBASu/uzqBBea6Fyaa4uo+4DGX+2tXF5ayAMb5jFz8QwEWxM+xc+amjVM9XpRio4CoLlovEHN37OMm8puYkzBFCRHI2f3uYz+uf1h5yd0OLvzUPgGztXcLGvbxSVLLmFL4xa+qvoKn/tzVE3n453vIOs683qfi6/yNm7o9S4bfrmBL2Z+wbCCYdyz5h72tu6N9FlMADBEZw1NwSouHnoJQtFQqN8OQE/bibjbrjX6ESmzOqRk45BETut7Gi7ZxSv+A3D+C2wYMIHzll7MbStu47xF50U0YhIZNS1SPrcXF1EdbOLB4x9k0dlLCTVOZ3DGKVw2/DLOGnAWI7EzvHITDk02XVfskoDSOZKnT3iR9856j2l9pkH1d2xiGFUZI+hW/SNlRWXcNWYeejiXNQ3v0zurNyf1OomwojJAqMFOiCx7FpN7Tuay4Zchtk8lTxxkzqPUsI0Vjt9wS8UqGnwNzFkzh7KiMsZkXEGCTnDFSm5rbSWEzAWl2ezvPMBfpv6FmYNn8mnVQkR7PYqqsbxmDcf5A4iubgCMLTqRK4dfyTu73+HV7a+S3OJ1cXxhH89um0OtTWVeYzMbT/sHE7tPZF94ASG9lbWH1jKxcBSirlIrdWe7/RjOaGvibHcvHjj+AW4YPhvJdYB6/0EeO+ExRhSOQG2v5Q+2v3Lfwa+4p9sU+uX0QxAEHpn4CHalHyoh5g+/gRxNg+weKJqGLAoIgsB1I6/j2ZOepbytnJuW32T+1icLnLboWWxwhpAFmRN6nADAMbkzCDZM58LBF/P4CY8jhLyU7XqGUqGVnFX3MzRnIO/84h3GlIxhZ/g1vEXz8YQ9zC27FaH9IDttR7HLOYaM3L684JOZ1mca+9r2kevIpTy0BMWxlXWH1qEDk31+GihElgTGl46nrKiMN3a8Ye4vyY5BQamCVnUfV5XdSLa7BNbMB01FEATOG3Qeb5zxBm+d/i5oTgRErssYBIJEQMxA6RjJxoZvEs4mTlkE0cdda2+jU20gVHshJ/Y8kce/fZxP98f0dqIMPE3TCSoqgtSJwpEJ7/9vtn8bAKPIZVC/TAZGGhHPaMY1KqCS7rqfooHRGYqJAII1A8NKjA1idoX/rRKSw2Qu09WxR0U8U1T2LZwMovf+qUGL1YE+mnGNL5ewYo6AESxYMSngMAwMbwPy7qWm6Fn0c96w1xw3n+LDITlSWA9RPYn4cUlno2r1jOkAoHSiqWafA21IrZUJHufJJQbRcpXk4DPHaR0wi4KYEjBlO7It57ErRsWRlpykA6Ks2B1HGvRBRANDx6hhjbSSiMd1nbeO5kAz+c78BEHRaIvPXHcEOyxBjigYEi0r84Q82EV7yvub5zREQaP3S8fiSWZqQEQHRLSnOCJZAUomI8tCiLJLBkbknZC+fibh762EIpPXkMkGsQA/rUo30u4FFqALpAeqYsKjiXOX60x0lEonWplcZgVdCyindeARbQlzk67fUdvo+LV2pCUkVu9MFDxr8beYBy4rACPeNhj+vxDxtGJSJKf8juQadF1/Qdf1sbqujy0qKvpf6Vxyc9vciH1PYGTVZu495jc8dsJjFNkHp9jpndH6MY83NFPTfoDPKj/jmhHXcLztCeTQQKo6qph77H1MrdrCD7bR/OCeCId+MB0SbGZtumYEYrITr2CsBVvuIP7qtzOhxwQe+uYhHAVr2etbg09XOUt3g2DobNgkEXoeYyjWK0GO73Y8Ja7e2PNXs7FxDScUluHQoUkqTlCnP6rgKKb1mcbr2183gcN4unhI0bDlfE8QhYeVDJyr54OuM6XbOeiqk8UHXyPbns1xrfV02A0mrD0jB/fIC7infDOvTfkjr5/+OqIgY8v/mi0NmxERGB4MEZCN9+fyoTdx2+jb2Nmyk1tX3Moj6x9B1/WEEpJadS3oAmf1PwsAofcEHm5sxCW7uHv13WhCED1jE/lyBqOCIXDnm1nabHs2s8fN5pTep/D3rX+nyd8UUdo3nnF/5y5EewuTu0+F3N5w8zpK7z7E7OPvZ1P9JpPlkcLAUDS2iIN4Ki+Xl6o+48LBF3LJoOuNf4uuj11LOG3rLN62z8N5KGaJC9Bbnoqz7VKemvwkp9aWQ+koQopGsXI2n8/8nOWDruXR+loeGHkz7eFGbHnfsKTyA/prIiOcxaiajiQKlBWVsfDshYwvHc/D6x/mx4aYo0WyC0kgrGHLW8fn3o1c2t7Ja92mG+u815vs9X1FQA1yqteHL88Ao+w2yRC+rFiJqMM1g++nc9cjnNfvOuMLajdzKGsUIHDNUVdzdDBAH1ch7531Hqf1PQ2P8yuCeidLq75kss9PRpYhfOqyOXHb3JRmlPLsSc+SYcvg3rX3RhIqiSKytuzNSILMKX1OMaxX67cBiSKJeAwqfBM5yJJIpj2Tq4+6mi8OfMGFiy/kus+vQxZlnj7paUYWjuShdQ/hU9oSxuZ732Z2Oezc5xrMjMEzyHYav+/+UORLlCC8djZZn89ijvwOjsh7G31/B+eMYHDeYOish/YqftAGUZNVZojBBjrId+biO3gNk4ou4s9T/4wkSvTa+ke+dMxm8KeXJJwB5TiADSBv60soSBzj6MMDbX4uH3IRf5n6F+yyPdGFpPZHSjWJUP0vKBXc3N/UwvG4uG30bTglF46STzjo3UNNoJFTvD789oLIMwj8euyvmd53Ok9veprv6r5LWKtSHCvmTz/8iTp/JRk1Z3G2x4ujeiOzx81GIUCgZD6doU6mZxpCsYfE7mx3GiVy7DfKK07vcz6ePQ9w91FvM73vdNB13B9fz3TxWwo7dsLr50KDoQ+RZc+i1Pcbxuh/YEKkr1pGMZpOwj42tc9UnpnyDBXtFfxuw+8ia19E12Pze1AvZrXLxriiUeZ50CHZCDWfxKwxc4yz6b7lyFqQV5TTED21UPEVuc5cXpj2AhPcc5FbLmLROYsYEhHzPCD2QpIlGDmTnMpv+P2YO1k2YxlvnPEGWWIPtNxlrKleQ75gZ5iYgVd3IEsigiBw2fDLqOqsYk31moR1ZApo5qzGLmRwzqDz4ZQHoGoDLL49wUJ6SP4gvBW3c0npXzkOJzhzDJ2LjqMJa2He3/O+ea0qeHD3fplqzwGOz7wTe+BY5p84nzHFY7j/6/vZ3mQAg1GgNaxphBQNR8kn/L38V5ZObj9n+7cBMJyykyx7Fo3+RjTdECKyYlakZFxD1kyNfGc+fsWfQOGXRTmVFWAR6FkFvS7ZhU20pWaoVeuMa7K9Y3yzoj07JSd20X5kJSSObBRNSalNTxeA5zhy0osNWrA7oOt68+SMq020WQI7VgwCOAwDQwkaJQe+GPiU7zCCStNS04KqDUbgFNJCCeNiFRCl0y+wej5IX4ITbWpLOZKnwVBQjvYlSZfAFKGUrbPnycCVQ3KkWginAcUs2S5pAAmwzianY2B0WUJyJAAGAjJAnGVtjiOHLFsWVZ1VNPmbTBAiuZVmlFLnNWil7aH2FJ0MMNZfpi0zEdC02A+SAYzofCQHktH5aAkmUv6tAk6rdzwKOibvB125+wCo/kjgsXtZyndEwS1N1/Arfuu1n6y5kq6EJKm0Kdqs3GYOZyGsRhkNmxPr75P1hwJKIIXpEu2Llf6LQ7YGMKxEPENa6vpMC6pavCdOyYksykfEwEgGTON/i7oCMJIZGFZlQP9irRroFff/PYFD6a4RBEEGcoAW/q9a7/Gg+M1DtSwmBhfsWsqlnS9zsr+DlQcOsvL0d5l1zCxybN1xNd/Aul+u44KiY0BTKBf6sN81AtBNtoQcn3nzNEBmMaFIcK3kD8LVtI8/nfRHpvWZhr34EzZ0vMgg3caYSPY0HFWJ73GMsVfWb0MQBKZ1vxjJWU9HuJVzcgyZkUaxyBQDjbZfHf0r/IqfF7a8EPd8UQBDRc75gf6ZI+g9/jbDZrFqA5mODIJNUwC4Yehl2NQgHTYDRLLLIoy+3Biz3Z+S78xncOYEbNk/sqFuHUMd+WTqOj7J2Gudso0bRt3A5zM/58rhV/LenvdYVL7IBDBUTaVFWEemPpySDAPApmQERZ2NzDtmNnta9/Bl+z0IGTu5OH+UYb3tyjMsa+OCnFnHzCKkhvj7lr8n6CxsaV2NrotM7nmScaEggCRz7sBzmdRjEs9+/yxVHVUpmglBNYindBGv5mZzsZDHvePvxR6pFTfFWze+gteWb4h9fv1UwrjbJBHRO5ZTc4ZA2AslRxnWm7JIadsX1O8AACAASURBVEYpJb0nAXCsAoOyxuIsWUp5x24u9SkIEYZJtE8ZtgyePPFJumV04/avbqeqo8r8DoixDA50HMBR/BllBROYI5UwpmE/vzvhd4iOOmNd2fMZGwjizTICUIcsQo8xEPJAW6WxVnWbATD4WqCjmnr3IAQBissu4bWGNt5yDqN/bn+uHXEtuhBkt/4HmkLtnOPxEo6cx+JFPIvcRcw9fi67Wnbx4tYXjRISNeqaEkbO3sKw3HHGuaR4qMFSCnQkiCTiqUd35hLCZga214+6niuHXwnAjaNuZOFZC5nWZxoPT3wYv+JncdVLkfk0LFA3ti6iWwhO9RlnQEkUsMsx5wbKvwJPHaqrgEukFWTqnQnPYu4JkbPcdrUnzVlDAR0ad2GTBfRwAScWXkG/nH4QDtB398s06tm4G76H7TH2jE0SCUefTQ2TU7mMZdqx7Bs/j5mtjdxFATmOHGyimGjVfOgHfLmDCbRN5OFj32Wm6oQv5pLvzOfSwdchZ+7ltYr7cAkyU30+fBFQQJYMZ7mHJz5Mj8wePLL+EfM8AoaAsKLplLeV8/autxmdN50a73hUVyEc/IYBuQMY6DgdJA/dM7pznG78Dh8SS/HZ8iF/AFR9F3k2AXQ7gh4549d8j71mPfOUS/nihPdBdsDKx8zvNi2YOw2WTTgiGZAsBDuh+wSuHXEtH5d/zKqqVYmuTcBmKZNKu42TswaYn4m905ExrPiKgJzFE8pF6JLDtO0VBZES+zAEz3i6ZXaDZkO4t0rsZvRj+Dmga7Drk0ifZYa5zgV7HZ9WfsoJQgZiVjeTOQIwtfdUit3FvLr9VXRdT2DiHWyvQsrcxrDMU42kU9klMHk2/PAGLL3T7L8oGGPpkgoNq1VnjsGeCPTi+G6T+NMPf+K+tfdx+4rbeWbntYiOOm4f+QjZ+nBcNgm7ZOeZKc+Q78znN6t+Q3uw3dwzFVWnsv0AcvYWxhWemnIe/Lnbvw2AAVDsKqbR10hnqBNVV81saHyLHhoPy8CI2DBGD9JWbiVgTb8OqaGUQ3Q6m84oAyM545ptz7Z0dYD0YpvJAVFXQnyQXqTOqlbbMutqEbQcTjsBEkX70tqXKsGUQ/oRMTAEkNEh7hozyx6ZcyuxPEhDpddSRTy7KnsBawZGlwCGEjAOXL5YljVZMyUtAyON+4zVRpOOgWGp2dIFWJROZyS5H2Cdme8K5EpuKiDpOsQhv4Ig0DOrJ1WeKpr9zWkBjO6Z3WkNtuIL+2gPtpt9TG4FroIEQNMK+EwGwQ7HwEjWz7HaO7LtqfORjoGRZc8ioAYSDhTxTYmsDzkpSR2/J0SBOau1n86296esfasSGUj/viqR9S5/9/eEv89z5qU4RR0pAyOoHLlmDViLj1qBgmANxgmCcFiAEiIaGEmgn8ka9DeaAEY61mA8A8MbtgZg/4Xad8AgQRD6CYJgBy4GPk665mPgysifZwIr9K78s3/uVjTM+G/THiDJHlXT4MuHOCD2Yl6P53CrYXIi1o2yJJpABE0GPf4A3ah2DwdBhOokEUU1wsDILDGZB1r+YAh2YPO38MTkJ6DtJPLlAczz6gjZ3SOfi1iz9hhrfFe14S4xqWQ6gbpzuGLQnUyKMDrqhSJsciK4PSB3ADMGz+DNnW/yzKZnEKWQqZmwt203kqOB8cWnwqgLQZRhz2eIgkC45UTmj/uEK7sZdOx2uQBBiAAy3cdAdg/D3hAoyz0NQQqys3U74+Q8kByEcETGyeiPTbQx65hZjC0Zy2MbHiMkNBFUNTbUbUARWykRToh1usQocZgsZvHE5CdQ9TCabxBXZAw0/t2VnxDgA/TO7s25A89lwZ4FhMVmwhH7yR3ta1G9AylyJ54ZBUHggeMfQBZk7l93P4JonMdUzXBD+7rzSXBvY457EPfVVCJBwuEfVYGD37ArbwpvaNMRyldARwyrM5kubRGrzby+BFXNBEGi9q20lHNWj5tRAyUcWzyZ89rbwJWLqic+X44jh+emPoema1z3+XXsbtmdoIGh6Rpv7HsCdIkbh89G6D4a6rcxqcck9OazyZcHMjdjGILsIiBHMtSyaI419dsTGR0RJkSda5Ax5648GHCyaf86rGAYLmUoXqGcbrZsJvv8KJHf0vh+A5zc+2TO6HcGL2x+AUWqMa0kd7ZuRbS1M77oZOPCXIPBQdtBw60kui146tAyDXArGiDKosyd4+5kwVkLuHX0rebvSP+c/lwy7BLW1i1FdNSiaDpbm7bSENrHuLYc5LZKs19OWcQfijAjdi8BRw4HT30ZlxCid72hMRB9f0ORrDzN5QBUqCW0Z0XKQBp2pAIdVeuRVR/3hK8nnDsAvo/K/hjrKBzZA2jYgRzuZJU6ikDxaCgdBVvfM9eQphtOQ8a1u+jIMdgztoxcGH+T4abTXs05Ay5EDRbjUzu4KGswOZqO35Zvfh8YZ5rfHvdb9rfv5/ktMWtQwxlG47ENj+G2uTku71JAQOl5rAnEHp1xKVr9xbx42ovYfM0giDRpWQa42utYg0Gg63FuKJHn2/4BmuTgI3USamYRjLkcdn4CXuN3L2rBjKceBAklwqRPtgkFuLnsZgbnDebBbx5E0Y3f/CjItdNlnCum6LHzWLLzB3VbacgYgh8n9BwHB9aa14pCjBlEczmINg5phca8loyA/P6wM/ZT1scxAd3fhyx7FleGbZBRaLDCxNh+d/3I69lYv5HXd7xulpCEVY03drwFCIzJ/YVxM0GAk38L466HTa9CW5U5NmC4O8UDGAAPHf8IE3tMZG3NWio7KhmRNx5f5c0MyzkOf1g1HUjynfk8eeKT1Hvrmfv13LiyM43FlQtAFzm524yUsf65278VgFHoLqTB32DSwbsCMJr8TYZwWtjbdcY1GKt57wrASAYOrALIHHsqkyFd0JvO1aGrzyQDAVbigZAewOjqvh3B1JKTrkQ8uwIwkoMzq3GxtKK1ZSIKYtcMDEHApusQ5zkdDXCjWcx0AUA6O8nkuZRFmSxbVorg538bwBAEZF036cRWfemqhCmlzxbsFbAe5+gzHmmgChEbVQuQy+r6dAwMAaHLsppoUwUMcCdJGbtXVi+qO6up9dZS6i61/Gz3DONwX+utNQAMCwYGGAGiKeKZxr0o25GNJEgpGhjJgXWWPQtJkFIZBBZ7hxWzKR0jK11QHW1KxBVFTgrx4stousryJ4MB6crPovOcrD1htRdYrc2EPvuMMZcs+pwwfmlKJqy0edKx30RBTKuBkcKqSCMQasXuiPbjcGtZ1VJFPIvcMQAjOkZWZU75znw6w53mnKQTnv5XaRFNi1uBz4CdwAJd17cLgvCwIAhnRy57CSgQBGEf8GsgxWr1n9ry+xuBe6NhGWiTBDPA4uA6aNzFW7YZtGb0h57HmgGcLV4FP5Kx2083NFuGkZFsMPQgEoJCTwNklpjq7xRFgtjG3ciijNx+FpMyHmBYewNkxRgYNkmAnJ6QWWLaY0qSSLj1eCYW/wKh8xCIMq1Cjln7H9/uOfYezht4Hi9ve5nOgifwqsa+sbbuM3RNYnzxFHBkGcBE5dq4Q7jT1O1olQqxR+jRiCIMnAqVa0DT6OseSbjjKHId+VwkFRgMici7Hx/MSqLEvEnzEASBbzufI6QovLXzLQQtg262Y2IdjguqT+17KucXPUeo+joyAp0gOcDmIqxqprJ/tN1UdhMCAuWhDwmrGjtadtCu1BPuGGkE60mtNKOUu8ffzab6TbxWcS9y1ja2NP3ATV/cRKO6DUfbxVw25GIItkP99sQgtX4rhDwcyCzjU2ESoMO2mGifIZYXB2Dk9jYYGNHMsjMbnDnQVkWJuxe+/bOYPephbCGPqfGRDAT0zenL36b9jbAW5tKll/LnLb9Hcu8lqIZ4fsvz7PdsI1B/Jj2ySqF4mDF3vhakzhM5KfMRjvZ7IbcXoUgQ5JClCIAnQP32WBmNrptBVJOtW2ycB0yF1v3QYghlloR/SZ42ifmlJyMD4cjZ2ir4vOfYe8hx5HBQetk8L37b8BW6JjO2OAJe5cUADKOEJApgNKBHMvPJc27Vbhx1I245E0fxUhRVY8HuBdgEJ/kdfRHaDpq6W06bFHsXa36AnmNpLyijWi+ktHYFAHY5FvAB0FKOLjk4RAGBjB6GuG7DzhjQEQ2W969BE2S+0YYTGHg6HPzGtM2NdwLikFEStEXvb3zXUecZ73jHoUSXmbAfvA14XIakkFOWjGsBdi3FJdvwH7iBC3o+xB22HsY7KBi/f/HraFKPSZw94Gxe2voSmxs3m/MlZ//IhroN3Db6NgTNiJuE0pHGXIf9OGQ74fYx9MrqZYAN7kKCmmCIU/Y6FnxN0LrfDNTNcaj+jmBRGR1kGGM07GzQVWPvIE6M01MHmcUoupDS52izSTbmTZpHW6CN9W1vxMYG8Lr3MTyoUtIYsz1OsBlWFajfTr17sKGv0fs4qNsK4UBiP8BY43l9CWqCMSeCYLAwKlaZDHCbZCNcfTMrL1zJIF8HuPMje3VsfV4w+AKm9JrC/I3zea3iAQRbM9WdVXyw7z2U9tEUOEsSH3DCbQbTY3tsHxGFCIAVATCifSxw5fPHk//IqotWsejcRdwy4n60YA8CioY/pBo2wZFWVlTGrGNmsaJqBT92GCBMk7+VNbWfonSUUeguTBnrn7v9WwEYPTN7Ut1ZTYvfWDz5rlQAI8+Zh4BAU6AJn+JD07W0GhiQyMBIl7mEwwe90WvTiXimc9xIR+EHsEVUl83PJB3o04lVdiW4CNYlEIqumLT5+L4nB1pmv61EP9PofaSjgiczMERBJMuelTaIA1CIBHFxdHtT9yQCbPnCvrRBHJDgDBBQAtZggIX7jJXIHxy+hERBMIL0OBDM7EsgUcQzeQ2mE438KQyMsBa2zPiDdfbcSvTTJtlwya4jssOVROmw8wiAphoinnqiiCdAn+w+HOg4QEughT7ZfSw/3j3TADBqPDU0+ZtM8DK5xTsTpXMvEgXxiMAAURBT3GzSMjAi8xEPDKZlZDlS7TTjmxJhhEhJDIwiV5GZvU/H4oGY/ku0dSV0CxZ7h9VekKYUI9rUyNqWk4DRfGd+wvhZsSog9g4eTrPmcFbQyesz/t7xLd2+fjiAEgzQL9kqOd4BJ/qeR8c34bo4AFbVVLxhryVL6F+p6bq+VNf1wbquD9B1fV7k7+bquv5x5M8BXdcv0HV9oK7rx+q6XvF/2mHZboAYjQY1PJ7izs5PQHKwXB9niKQNmGLqWyQwNZr3gbuQVi1ySC8eCg27zPtBJAvoqTdKSBQj2y8UDTE+H2F/yJKIGPYYv3FZBngbUiKHYkEwykhqjIyoFB9sepvAXYiiWwePdsnOwxMf5uXTXkYTO9ihPEdACfBd4woUz1DyXBFwrc/xcOgHJIxziKLqJqugWSxIVKvvM9E4VDfsQJYEAjWX89ZpS+gVCoIr18xmJpe0dM/szpxxc6gL7cDV+yVWV6/G7j0Bd7yIekYhZJaago6iEAku/K3gzgfBqNlPftbSjFIuGnIRB0KrCNvKWbhnIRJ2lM6jLAEMgLMHnM2jEx+lIXAAV883uW/Dzexo3sEI2y24QsdBnwnGhQe+jrMk1c2+HXQOoVbuYYisblto3leWRKPP7VWAANk9CClqYj9ye5vBOgBRfSVnLqrF84Gha/Lume8yve90lh1YjLvPS8zfPYPnfnyOo7JPQmk/xsi+Fkfcixt3RcC2SF9yehKMlE3YZRHsbgMca9kfJ2Qam/dWuTDWjwFGWVGUeu+ilO7hKxilSSDKhGVj77IKPnOdudx//P34hSpa5GWEtTA/NK9C8Qwh1xk5p5sMjAOx0gIATz1KRlFkXA9vWJTjyGFG/6uRM/eyoPJPLNm/hP6uE9mv9UPQVbNczNRhCQegcSd0KyOoaHyujiW/7msIelKZFc0VaLl90RGxyRIUDY0AGElAR9MeOt098eJC6X8yaAocWGc+g1mGVPsjYVsWB/QSA5yJWvtWrEpkM0QApQ6nAWw6bSIUDjSAzupvkSURXc2kt3M0krcRMkvMYDcZ9Jlz7BxK3CXc/MXNLNi9gG3ej3F2+4BRhWVcOPhC/KGIi1jpcMwSmXjA1tMY2ccigFyv8cbfV30bK2tSNUPPoW4bvgJjLdokEbqPBnumqZkhRcU4Ow12mrlvSNbv69D8oVw45EK2dy5HsDWjqDq1nlpEZzWj9RLjvpF1I8fPSWslKAFqnf0jrIqjDLAgUhIkSXHrraMWsrsngqRDzzKAl31fAgY7QtMFI4bwtZissPj1KYkST5/0NHeOvZN9nT+SMWA+d62/AofkJNg4LXVPyusDBYPMdRIdH03Xjb3BmWP+5iTvDVErVH9ITWBgRNvlwy9nau+prGx8Bcm9j3f3vEVQ8xNqOSHt3vhztv/xNwqC0EsQhK8EQdgpCMJ2QRBuj/x9viAIXwiCsDfy37z/eXf/Z613dm9aAi1UdRovsRUDQxZl8px5NPoazQOtJQMjqYSkqywqJAYWASVgeSi2CiAPx8Cw1CzoOISo60jL7k3py5FkUaP3TldCcqR6CFb14zbRRqYtM23JiSRIKbXgVuMSUNMAB2lYBABoGoogGDT6UAxsSSkhsRAyhNicx1tl6uiWwFWeMy9tOZBVVr5LBgYg6jrE6Qo4ZSeZtkwzsPaFfYYGS1KQ6JJdqdon6QI+ew5+xZ/i8x1Ugyn3jbJMrIJPq2wypC+JsJrH5IDZsikBFJOBkVg6UVZUZv65X04/y4/3yDSyEOVt5XjCHtNqObkVugpp9Dei6zqdoU7L/QAizkSR/SDKjEpXfhYv4plOAyPbnk1IC5lgAaTXwDgsA0OxZmAUugrpDHcSUAJ4FQN0sSyfcibOh5UVL/y0EhJZlMm0ZaYvIYn0ORl0yXXk4g17zbHwKmk0axy5KVo+XbHfrNabFfASvXfy9VasMDgyACMd6JfryKXJ12R+V64zFcCI/o41B5pNINNq3f2n/cytaEgcA8PIjuq6DhUrod8JtCp2nDYJ+p1oHHor1yYGIc37oGAgIVUzMnZFw6ClHMIB8yCuKkGjlDCOgWHP7Q72LLMExSYKuIOGYGE8A8MEDnocY3yXvzWR2eFrhoxCI2vfhSPtuNJx5PkuoYM9XLD4AjrCLYTbjo2xAoqHgxbG1Xkwdu9IMqVFzE886EaDlurvzEynoIsGyBBhEIARGCS3cweey5ic85Azyjm6aDRq6xRc9qQjbdEQM7gwggXQ/UagAEaQLVsEOTcffTOZUili6Ut8uPdD+rsmI5FheW20nTPwHO4vexvv/luYffTv+XTGpxRwrAG+5PQ0wJRDP8SCVEWL0MxlGqVI4DlypgFuRUoMDJeESOCZ1Q1ke2R9xPUjpze0x/Q3BH9k742Mn5hmLovcRTw66VGWnvMVvqorGJ1zFr8d/1tOLbodEIzsfBTAaNgRsc7Vob0acnqZlHozSIwAKdFgTVV16KgGdyEh7LGgrGCgUToUyZ5LYkRo09cM7gKieF46kGFq76kUCcfR4VzKQ+seMtZf+9jYmLgLwJYBrQeM0gJVN4JRTwNq5DfeChyxamf0mYniGcLXDYvItmdzlPsCdgmG9gd1WwCjhCaoaNCw3QAYuh9NUNH4QjsGUQtB+ZdxJSQxBoaS28/8PMXDExgYZmlIy346XIYckNB9tFFWdugHwHDJMcsVmvbiyR4ICMa4lYwwxmH/6kSXmQiTp8NhJG+iLin0OAaqN8YBmphaO1F2QvKYZduzeXX6q/TM6skj6x9hXeurqP4+PDbxaSTRYKXYJRGxZITxgYadkUA6wgbwNkBGUWRvEgwQx54FVRti2hSqHmFvePHmG4wqmySAZDN0VyJjISUwMErMPncFVF038jokQcZe+BWKprHioAGo9XFPgM5DCWw6iOxjkdKhJlsPY72ZLC+DKZfAwOishaxukT0m0o/uR4MzFyqM75IEYzzQNPC3gLuAsJrKmpJFmSuPupKHx7xBqHkKE0um89jxf0VXcnHYLPakPhPgwDdEFWyF6PeYJSQaBgku8XuigEVQUVMYGNH7PDrxUQocPXD1fol39rzCmPyT0YLd/mVtVBXgN7quDwOOA34lCMJwDErnl7quDwK+5P+a4gn0iagbb6w3sg/RDFdyK3GXUO+rjx0aLbJeUfZGNOPqCXvSZi4h8UDvV/yW13blOmAl4glpMuDBdqNMIpKRif/MkdiodiVSBxYMgq70DY4we9nl9RbjElJDRyx8GG162G8AGDoJmglu2Y1DciQAGEdSQpKubCPdM5rjbcFm8IQ9plVScgsLOjZIYRlEA2uI2F9aBJ6CIFgKMKYD0CB13kNqKKXP0evTMTasAAyrkgirEpLotYdlYIQDaFEGRhLoMrpkdOzPxaOTPwkYwJVDcrCp3qBTR91Lklv3zO54w146Qh20BlstgU8w9pPoftAZ6kQWZMu1YeVg1BX4Gb+e05ZxpSnRiTY1An4lsxniS+aiDIx0YEBnKKa5Y+plJGuu/AQAI3p9OqBKjXyHLQl0iWe/6bpuCC1bBOzJ76uqqYS1sGWZhxXg2FW/j9ThBA5fQqLruqVuDBjz0+BrMBkn0XmOb/EAbFeg+3/az9wKhxiHbSUYC0QCPuN3uPtogopmBCs9xxmU8co1iUFIBMAwKcTFwwygo3mvGYQIUR2kSOYSIi4QhYNi+huySEYwYhkbYWCYGhhgBCtgsCSEuMO5twncBWiaUd3RVcvRxlOgT6Cyo5I+GcNRvYNjB9iILoOrwwjCDXG9Q+AuxK9JMaADjGy5LQMadxH9a0WLlEu68mJBskWHBEFgStHVdO5+iGcn/51gWDSC7viW18cM2kxQxmeAI2BkeG0WQU62PZvTCn6LGujF2JKxHOW68IgyjC7ZgRbozdEFEyh0FSbSwbuNgtotiY4yLRWQ24egJmKXhBidf5vhDBADDaog1whkE0pIwPj7toPm+AnR8jpXbko216plOtyonuFMzL+ai4ZeREg1rnfYRMjuDo4cqN9hABNKALyNBoARCY7M+0eZIPHz2F4DOT0iQVm0g4IRfNZujj2jFhH8dBfEBczpx3uwfCWSWsSi8kX0cg9H9QyNjYkgGGPSUY0kRDLiIQ+EfSgRXSGr9WTV7JKMv+pKrh34OAvPWoikZVEvlRqBdm0UwIiUkESeJ8rA+FYbimrPhr1fxJWGaEZQ2bKfUATAsMuiAbR5G5Ajv1VhLQK6tFTQ5uxp9NmVbewxkaBdjnPJoaUCT4YR39j+H3tvGmzZdVYJrn2GOw/vTm8eclBmKjWPlm3ZRha2MQZsbDBuMLSBMo6imqEMxRTtcjWmB6rLAVQVTQFFN2EaOiAoOlwuhipMQxtwhWyrJVuyrMHKTKUy8835xjueafePPZxp73NvZirTEpFfhOLlezr33H3P2Wff/a1vrfWZBnuAFx4AVp+Id8bZZ8/CXn6WH8vv3cJ9wO45WPx7yhfdjioz0utGxeSZq8zhD7/9D/Hp93waP7T8mxi8/GHUciznGQmmUGOFAS875yLsoyBkYAiDYcNkCf6lJ+LH8et6MBVhYAAMpNl8Fgh8mAZnKh1uANUZyWDJus+dUgf3TL0Ddv1JrHXX8ZfnPwt/1IE38+3sgOf/HEA4D6MMli1zmo2jeZzJ0TYZk8rkrC4EAQNta3NxFpRhAse+ibGPKIVB+H0Z7rG1vtSCFwTacXdK03C23oH/5thHMVsUAJiZPnDhPiZZ2+c+GAScgRF6YKjuZ4EDFkOXMzDs9LkruQo+cuKTcHdfj29d/i5859JP6sdxneOaAQxK6Rql9An+70MwzeoCgPcAEI4znwLwndf6Xtcay7VlAMDnL30eRauoTUQWq0xqkuWVUbWryJv5UBvvHCo19BW7AotYMdlBVsKi2hQDV8jA8IY84Y13AkiyE8S5U50SCnF5gggtA0Nj6KgywAP01fWsJCfFwNBIN7KSBY9v7k3EJQeEEGaENwwBjKyEaFzrUvEZVbIXVbvMql0FBdVWaZnshesXI9EpdeT804FiAGulGqv4+xq2UE7dGtUNXGVipruPjttHbu8i+4KKhIqBoQNHshJbGd6Am7IiBkiJ9/qdd/wOfucdv6P0DQCYnONk4yQ+d/FzABh1WBWLVbaBeOngJewOd7WmoK1iSwJKgqmRvNcAZ2pEJSS+Zj1QPFc63xoJlGrkGEJCkkyRVQCGTgpHQeXc6Ht9WCTddUmsSyoPDB2opWeNsHuaZGAIAGNvtIehP4RP/UzAUZxfMKB0cznpWSPGrQP7roSBkQVgiPbRquuzWF3EhcML2B/to2yXlWwQycAYXMahy9aQmwyMb0B0TrFN6M45uTkMNr/GKMOzd7KKpGUwucnC/cDLj8EyDAQU8Af7LGFoHYfrRQAMIFaZNXqcWVGZgeMHoSFm+2QoITEIKg77Xkh5YADA7J38vM8lGBjbzEQuSPtCJMM0CBb9D+F3v+V38f1H/icAJEwg28yUsLD3YnjugzWgNsfGEQUCDJ68bT4rmQJS5lGYCpMnTRKes0wgyMP1qZLyjKkVlnA7Pcj9+mAHKDUQBBQB1Vfj24V5DF7+MH7jm38bJKhOBGDE5BMAb9MqrvtdwPYLsAK2Frs+ZQyb1nEGpFicqbH8RuDp/8DMDIUEYu9loB4BMKJjqc4CTheWz/YHZMjXUy4h0TEwRFiJMQtgLG+ZDAzonGLjNgmqDpclTy1JlkAuysA4XIXF17OAcglJbQF+kACK5u5h4M1wn7EkKEIGhpQs6MddNCuo7HwU/+at/wYfWPoEABKvRNfmgYPVSGWePTcuBzAmZWCw4wwcKd2DTqnDng3TZM8QT6xzloGR57PfC3UGSHk+fJjoLzwMnP1/kYuyIA4uAv4Io9ox+XpwGRjZfgE50f2muwG4PewW2H1n0ol75PvKLjlOHzi4hMNS5DiAySy2X0CeRCXwrgAAIABJREFUsvnm+QGbR4aFA6sVv3dt9v7WLgMdPXHNytNSbqC7ZgYxcHzqODqFhfC1AANsbYOxJWoLUtIDAJ4XhAwMLwLyLdzHfFT4d7XnU8Z0MWwc8q43IYBxO+titPsSTAJQ32PPemU2lEiMAe8ebn83AIp//eVfxhObj8PbvwdeeZZdu+cYgGFHn4/9C4BhYZs0GeBoWsyDaEN4FbG2rEFvGwhcycCIgXHH3soA3Z2zocFmjxe0Sq34mpEIKWcJAjbnAPW61GEmrULSaBICeA7g9iPSsvTrCvxcQkJSSK6nPBr5JkYb78GHTn0U4J1iXpMSkmgQQo4AuBfAFwDMUErXAAZyAFDzs29gLNeWkTNyuDy8jKXqkjK5AJhXxmp3VVbkVUwNQghjavRY255D51CpOyaExCquWbKDep5R+KOdBGTXAR1LQinFGKUqrdHzCyaA6JSQMvG0q7CINbEJpY4Nklm9HKrGraZrq66L4zvKVoE6VgAA+BwgYAyMuOSgVWyNlZBYhoVqrppqlanrWKLUyGuqv0AG/R+UMWoUDAwBYPTcHsqW2rgvOZa+21d+Pl1XCJWJJ6Bnu7jdDeT2LwFP/VH6+EQiN/SHymuiAoBS4Y1CD4wEAwMAHpp7CA/NPZR5itu4rhIATkydUB6zWGEAxle3vwoKqmVuzZZnsdHfYG2aNd2LgLSEZOCqu2iomE06DwyVVC0aPp87yXVBGEVuD7Zl8lvOpeeR+Mxy7rt9FO1iag1VSZYA3jVIxZhSsKtESN+OxFImW9EOd6TXiGrtFQCQWMd0shdxTi0DQyMhUZp4ajwwDpy0ybEIXXcnADhSO4ILhxew3luXXUmSIaRPm/3NkIFxE8C48dHi3S22X5BSg2D1afZz+k74AQ0Tz6WHgPWnUQRLOj1hGtc+EbIlmsdZ5XL763LjavU5gFGelowOQggDDQ4uAaND2KaBqhtnYDhRJkC5zejlWyGAEVAuISm14dM0tTgZlkHg+wYemH1AtjqUny1fBapzyO2fY5/Np5xOPa+u/E2fBjaflRtqqdWOMDB0yax4z+7IBaVhBVFG4wj7ufdy+Jk4u0MkWjqdfNSPYOQGE1UYrajhHxLXfe4ugPqwtxk13XF9YOcc0DwWZ8jc+V1M9rLxDAyDgNAA9OASAwigADC4r0PBYWuzIb4Dig34VF1pjY+ZA0d+CGCYBgkT1vYJNgcNgtqI7XdRX0zT9OtLAA2QHzCQg3lgXARqC/CStPg5LvFc/ypMYTDIGUDCIyELZLAMAt8r4K3LbwUCtubGWCnVeeBgjcuGuG8MAKc4uQcGex9RfWef1fUD9mwv3g+sfRlw+qGEZP1pBlIRIkEg58gjwP4FlHvn5OuFPKhfWeHjNsNuMlvPh91FuMnpdo4BA7ZJmNSkuw70d2CLVs27LwEA9rnURN7v+XsAGmC6x4BNV3SzqS9ixFk2dgJ0tHbZOmQ4Pda2tzIdAkpjrpn02ojMI/nMTK0Au+dDgG94yAqsgoEh5vP8fUDgwtz6Gj9XwJguM7fBYWXZEAgTAO/GMzANA1V/FwAFqjNa2UsyWsUZuPv34Uubn0fOyMPdf4Bdk1PfxnyCepfjrZH3LgC1eTjCeBRg92Qr7lXkHzDTYlQTDAwAWOSdoCIMuIAblqPUhBdQ7Zok5rjrBVJCqFyX5HxiPi0GIbA9XiAtTsU6nURDAMDCxLOkYGAAUVNaGjIBX8sABiGkAuBPAPxTSun49gHh6z5CCHmcEPL41tbW+BdcQ+TNPO7ssOrDrc1btcctVhfhBA6e22GTUmX2CQAzZSY1AVjVWtfFIJpoZlXtVRVwLQMjr2dgeN6IJbyJEJU6YWIqEvBk9ZcQgqlC3OkfyGijmtcwMK6QNq7yzADS18ULPHjU0zIwtAnRiG3uVWCAYGC4gYu+18+8l4KpkSUhETr9qJ+ELsERCZmqAgwALqVKRk2n2JHdcvZH+1qmQbsQjhnQy010DIys+6I0Y/VHyFEaMx0FODsm8besazJeQjKAT/gixufmlcbrZl8HgIEKKn8BIGRgPLXFKKM65tZseRZe4LFKuAbQBMI2oEKOcSWMGB0LqmgVYRu2FsBwfcFmiEeUgSGut/B6iYZgnUwiWVIBWzp2QtZ9lqALqDTUAsL2otuDbZmwqxgYSZmfrm00AOV6B+gZQmLcMYNVDdDXyDfgBWmTY/k5ecVS9Ywt15bhBA6e3HxSms4mI2/m0Sq0sNpbDb1XbkpIbnwIAOPy11l1DgDZeBrIVeHWE9XR5dcD1MdCl23UKfevoM3j4YbeyrGN/+UXZSJlD4S3xWxcSiCMPC+/CMskqLmXGc09z9Yg10/IDjq3AluRFpqew+jFpRaCgGJcfmcJyjbCin1s0904Cnv/JXZuKgCMWXiKrh9oHgN6m8gF7PnwnBGj/Ee6aOiKTWLTvD9g62IKwEi01AQoY2AUmzJR1iX4UePFkeerteaJiCU7/KcdZWAAMDaehmUQ5Efb7HM2j8Hxg3Act34H+/niZ2EZBDPYBQm8UEKS9MAoMwCzwDviGQIc54nKODAqyRpxknOldQvQXUeNDDHl8MSsviRp+vJ+coCl0L3IfncO2ZyqL6STMp4w4/KLIUsiwcDI8mGxTEOCW8oEqjYPdNdhwQ/bawIY5dvxMY8JmZDyueL6lF2bY29lRbDz/xV524TnusyQld9jkVwGR98KAKhe+jv++oCxbhABMCyDXTurIMFPdhwDMLZyC7BN/gzM8ILLxjOwLS4h4cftFdn1DwGzewAA7QO2xvgiAZ9aDiUW4tjGUYCYMPjYcmK/WJkcDAjnUSCvgazKN1aAvfPy/YJDDoSVp0ODYYAxMACQ1ScYkOMHjIExe5dk/MhjW9E5BNR5VyRUZuUYdECACMswMNr4drz/+A/iX7zuk6Bend2PlTewAy49HpF8cQBoaiUOALQ4eOz0JNuJ7vNWyNU5eH4Qv3adWwEzB6x9WT6blLeDRamZPj46XjN8VkcuBzBU61KpydaFLQZeGQZB3uMm5dwDQ+UrVBhj4ikiarIaAimvUQCDEGKDgRd/QCkVvVs2CCFz/P/PAdhUvZZS+tuU0gcopQ90OuoK0ysZ33fr96Fsl/G+E+/THiMqrk9uPomckVN2HQBCrwwv8NBze/o2jMUWtvrhxh/Q07SBeMVVMjASm+i8mUfezKslJP4opRsX4wAQgileHzkjp2VJqBgEgF7OouqgYvMkLXnuK9Gby+oy/2KW0hcFA6Oer+PQOVT6SXiCgQGaYmDMlGew3lvPTOIAljzJezlGQgIgZXyoSp4kJX6oTj49UFY5T4AunWIHA2+AntvLBDBaxbANqBi3EkDTVPF1iZmO7eIErhJwEXMq1hXCG2nlVF23K+e/MrwhfHBPk6sEMB5dfhQfvvPD+OU3/7L2mLJdRiPfwGNrjwEA5spzyuPE39d766xbSQaAEZVjjGvBHE2sdRISHXAgwvMjDIzIM9nIN2AQQ7bqJCDKdUyABtG5r5UsJQDKgAZwgitnTHm+8O1A7P4KxsFGfyPTLFWAM4JZlQlg5KfQ9/oxlheQvSb51JesFQAYBSPkDTU4AkAJkADjGRgAA2F08w5gPi2r3VX5Hrr162ZcxyjUmGRj+0VZjTQ3vwrM3gE3EBVPvmlcfBAAwdwh181vvwiAwJs6AgASAEHrFg5gsN9zvGAiTDxzovomK24vwDYN1L0toBp6+rieIoHcfkFuuE0xN8stZevNZFiRbgIjVQLZPArrgOntqecwandtXn1uDjKUeOWeRBJwN9Bv5oGwInkwYN8TheRmnifV2D0PgwBFjEB8J8bu0J0/6lsQS8YyIkx4w4p9aHK5wjon8I4rlT67PmgyCYm8ftUZZuB69nMwDQMLhBf26ssIAhom0SLKbJ3Lj9g6Z4r1tFBHQLMNWQH23SFBBCgYHhxsWMElTDmbYN1Q5iVII+c0v9Y5bpKf63G5SW2BJUzR61xfYknczhk2BwOPd4eJeGBkoGi2SSSoIExwUwAGDVDzdphxK0+YRwUOYEzMwIiDO4yBQZhJopkHzvw/yJkGOs4Ftt+Z4wAG79BitY4CjaOoXGQAhuMxiRmsInr5Tnj9DJMlwlvPwzYN1j505yxATFw2ZsI5NM1NIzeZJ4kXAUT2uIRDfrbaHFCeRuOQFWLdgEtI6suyPam8d1YOaKyAXP46TIOgMOL7xSgDYwzoI84l5sXI9cN7MrUMHK4hB/ac0q6QwnXg+JFnq77E2GGrX4ZlGCgONxiwNXd3GpQo1JgxLgd4pwSAUY1ISCZhHwUFfM8tP4Lbm4wZkbcMBv4QI2Zs6vkB78CzFH+u2xy43jkbSgd52+iUBwbAJDUztwNrT4WAhwQwWnAzfGuSoKocryoaK9LzxCBATjAwpAdG+nWGQZCzDAw1Jp7JcTicnQa8RhkYhEHj/zuAZymlvxL5X58B8CH+7w8B+I/X+l6vRLzjyDvw2Pc9hvtn7tceI7oWPL39NJZry1r0XwAYwrtAl7BEWxVmVe1VrRB1XQcAfccN13dhI41gyA19pF2oLgmJdlSQYxEa8gTlv2AVUDALaQmJP0Tu8d+NtfMBuCGge5hKTnWeGdK0jzMURFcGHQNDUPiT4TmMbm5RpJLrhcoCDpwDvMw3XbpqfNI4E9CYeBbU7Ut1Uozo50uGSwRrJD5m0Xd5a7CFfWc/kzXSc3sScNFVz3WJlu6+CElIEixyAo8xMAbx8zQLTTiBI2n/lFImIdG0wAT0sho2MMbAMEGvGsCwDAs/ed9P4o0Lb8w87nTrtKzkCy+dZAgPjfU+A8J09yPqWSA8cVTJvWAQqACMSTtjiPD560wgBoSZholWoYXN/ib2hnuo5qqpLkBAXGoC6OcQoDcL1gEHqjkUHbOVmPslu4RarsaAIlfPwKjaVSYZTKy9OskXoPbu0F1rADEpnM7EU3Yv0rFj+DqYbKMKsHaHIk42TipfDzAAY623Jtd2nU/LzbjO0bqFVVENAoIA1tYzwOyd0qhTbhqLU8D0aczsf5n9vvMiq4wSts6GVcZbgMtnIPaGucEW2+BbOc6q4HsTXkHF9guwDQNNb4P5KfBg3hORfczUCjDYgc19E6yB2EC3WdI7QbU1TOrYz9hGunEUZncNeTiwBkLOMscr8UkAgzELykNWtQwBjAZjMGSMRbznwZA9Q6kNd2UasIrA3nkYhKABvi8oNWViNpau7VMOYIyXkCSr0G60y4lhSLmMbRqoSwDjaFxCAjCjv5cfgw0XSwLAmFqWxpkqCUlOABjOHmPfmHa8A8KYcbsRQCp2fl7pXg4uoe2usnll2iGDRYy7vgiAwO5eAgDkeyKJW0hT1g2TzdnLZ2CZBAW/C4BKBhCQnXxKc1NEALTo9auxZL7OpVT0cB0wLIzsqbHnTr4PoACk7CJw5E3Ac3+GggUsO4xBJfxlYqDekTchv/pFEATsWbl8BmgeBe8yGl7rzklg+3nkBPNg5ywwtYwRNcK5UZ1lBrQbz8SBjmITPcJA/Ng8mr0D9X1WhfdHAyY/4QyMnGnEc5vWCWCbMWKKTghgTM7AiMttYqAfvx81cT+6oRQuNvcJYTKS1SdgmQQdDr5g9q4I6JIEYr8OwyBoBIKBMZNmmGjHHIIuTnQe5SuMKbH2lZD14DqMSTa1FDfHlcy7F8NrdLAKgEgGSwqMa58ELp+RxruUs+JRZAwMnYmn+LtYk4AM88z6EusYBCYhiQIYvkZCAjAfjP7Ix8gL0ow2MY7I2igAxNekiSeAhwH8AIBHCSFf5v+9C8AvA3g7IeTrAN7Of39NxGx5VlYcV2ormcd5gYeXDl4CoAcwhOzAD/zMqn2yTSegp4wD3EhOUbX3AoclvEmfh0KcgTHwBtokJIuBoXTaV5jaOYHL2A4Xvhg/d0Hd8lEnVRDjFomIznwUyO7O4vFkR8VmEPTsZy4zN2GdTCAq28hKiFRJi863Q3XfZQQ+PPBODAoJCcCq4pkSkkQlWlfxr9pVWIYV65AR0IDJdVRGm7m6Eixyqc8AjITpaJLSr2srC4xvCwqAe2Bwj4SrBDAmjXs6jI5Ztsva6zxb4gBGbx3bw21tEhn1LHACBwENlOtB3syjYldi8h8BBhTNyUyARXi+A4tSECA1j5aqS9IoUtVxCWCfu2gVY1I4LQMj0ZJUeE/onteABkoDW1cDugBcvtfbyOy6QQiJsY8EcFa01Z1hgDR4lyUhASYDKK+FgVGyS3jL4ltgEhMPLzysfD0AzJfnsdZdw/ZgG0WrqL03N+M6R/uElJAsk00Ybg+YvVNu8mIGlksPobP3FAwEMEQHEi+xSW8dB9we8kO28c8PN1nVEawiKJNHK8ekGNxsseOth/4PSHgxAGG1nNP9bS4/YCaeEzAwDCOmdY+NGZDvvUQ2UejzSnx1Lu2FAEhzymKf064HIQPD17Q5FRFKSAQDI7GJFh0pBIBB+HdVsRGCSrpqp9B5e0HYUWFMWMmE14uATAADMDaegW0Q1IcXGOg0tRyXkADA8hsAb4Dp3gtYMTZAQYDGitrgkjMwcvx71RzuM4AMzFtinImnOJ8vAQE/DgY0GTi2RFcx7V1i8wwhcCUBJtMGqrOwOIBRGAq/jAU1kNI6zowMCUE14N9bsS4kWQwMQwIuQkoVS8ZrbD9Xc1miTLsbzJCSkrHnjl+XuK9DLNm+6wPA3nmcdr6Ke9yvsG4t3AwzRqtfeSOM0R5OkoshMMFlQ/IYgL127wIqpsuZFeK4iHcOIYyFsfk12Cbhx51jRrASkIt8tpnbUT38Okz4IAdc2jO1zI0zk0n1CWDnDGyDouiEEpKsLiTRsBPgHXtm+PNYZwBGRcwJDmD4pU7cGwhgMpKt51A1HEz3nwdAgJnbIxKSKOhyi+zS1AiiY57UtyNk2KSkSO2T/NycTdddYybN9SW4UWNO/jwI+R4A1oGk3AZMO83AEOM+uAg7YPsa2rsMGDYCu4KATrAmTcLAqC8yACMIYBgEBY/nRIV6JrOtmDNxucfGVS2k9yRAwovD9UEI0vPpBsQ1AxiU0r+nlBJK6V2U0nv4f39OKb1MKf1mSukJ/nNn/NleHUEIwevmmDb+gZkHtMeJtotPbzGjLp3JWqvYgk997I32MiUksjIbSVgE20AFGjQLTb1zPkUqgYy22wPGMDDyDX0bUI3OOzoWN3ARACyRTQApuuTUDdSV/qT0RWc+CmS3k3Qddu1Z14r4mKJGjQC0SWqn1MHIH+HAOZhIQpKsRKvGXLbLsIy0aSob9AAuIUrZi/BmOLt/FgNvoB+zADoGW3B9F17gKcdMCGFzasKKv44l4SBQAxiFOIAh7uNVMzC8AXxCOAMjLVV6JePbjn0bilYRP3j7D2qPqefrKFpFnD84j/3RvnY9EOtGjL2lkak1C03pWQOELAKdIaaegeGGBp6JebRUXcKFgwvYGe5omUdAnH2UBX42i80YCJbFmMoCHAUDwwBSc2m2xAxTxfvoJBNRzxoBYOjaxALp+eYFXqasLdYhxhshv/ms1CSLEGPTMayyAAwA+Fdv+Vf49Hs+nQmmz1fm4QQOnt95Xgu+3owbEO2TwHAfJXcPt5Hz7G+zd8oEKJbMLr8eOa+L0+Q87MvPAzO3p4EOXt3L7bE5VRxuJVqjRrXVp4CNZ1AhQ9TpQej/AIUHhg7AKLUnSnqtqOTA9+OmjwBLegGskA0UhrzaWpvjXRwS287qLGDYKPVY4muI56TQYJT9LAkJv057fc7AUGm264vA/iWYBkFdAhhNZmqICT0w3ODKPDBEF5JkR5fp24HBDmbMfTSHFxnN27TZ/YkmIstMgz+39wSWySaC2gJg5dWyF7sI5KoRBsY+wNdxXbvEZFgRRo2TlMtYeaCxgkX/ImbcKIChAK7qizAP2X0s9kMjw1QnBoAxMHgHiVrAv7fKrYkkC1aEgZGSvAASwKiO+NzrbsbkEOMq8yJMM56Ux7r5nP4OIF/DN+3+33id/yRwy6OsKwVY8m4Qzk5ZYezOB43n4XkusMuMW8OKP5+znZMAKI6RVW7iKQxeE8/uzG3A5rPIGcJT4xzQOJpmeQHAzJ0wAhfHyBoMCWAspbsBAQxQ8oaYN3YZgEGMiQGl6P+PMmPkM1Nje9WKwwAM0tsCQODy76rY/Zi/D6ABbicvYa73AlsD8xX1fGufAAa7qAb7aAa7QLHJ2WmTjTk03Q3k+XPRtXf3PGwue7EOw+vHWBL83LkyY5hcPiPXTXK4BlTneIt0xdznz1B9yJ4Vwv1fOH6tfWZDQC3I9sAA2BrvM/meQRDzwMhqr1ywTWwfsr1XOa/ek8SBFAWAeIPixotWXiPx0/f/NH7+dT+P9596v/YYsaH80vqXAIQ062RETecGrl5CogIwsqqXzUI8URDhBh5nYMQlGjkzh2quOhENfKrAGBhRancWFTyZaIlxF4U5UyR0Xguur9ebm8SU10WMQ8lm4JVU1XXxXCEhSTMwFioMIX5843EA+paa0XspEqIsP5NkhVZ17QghaOQbymQ9cHrwCVHez9nSLGzDxhMbTwBQd8sB4gBQFoAmzhG9dhK00rQ6BRQABuVdU5IAmmDSDCfzJAD0tHsAgDu8YQyM5doyPv+9n8c/vvsfa48hhOBo/Si+sPYFACHzJRlRDwchARPysWQkn/EsQHOqMKX1wHADJzTwTMyjldoKNgebOLt/NtNnQbCPgOy1o11sY3e4KxPzLM+arPavMdZIQm4mDJTFtdEl7a1ChIHh6Z9XnZHuOAlJFOwbeQPkLj4O/NUvxo+9BgYGwADSI/Ujyv8n4pYpluh+cf2L2rXrZtyA4H4BU72v4zbjPCgxgc7ptOEhwDqRAHi/+TmQwAFm7gg30Ql6si0AjFEUwEiwKhbuB3bO4ITH6eyNKIBBlQwM+1AAGMIDow1/EgmJSVIV8Fg0GICxTDZDAKM6r65GGiZQm0N+wJIbQ8iyJANjvAeGADCUrvn1ReDgEqOZRyUkfnainPbAuPIuJJ5P44ki75xwEhfRGl6QiYyXvD/VGaB5DLP7X8YK2YDPn39ti9FKBzZf5ywnwcCYBMAwDb0HBgC0TuCU+yyq9JAluggT1dj9iQIYg3VmJGjlWRvV5DgaRwC3j3qwh2rAv7cmTJgF4EIpZYyR5HiLDcAqouJEAYwZmeRPzsBIAFLR+5QrAa//Udxx8Dl0sAvcHvrqJTtw0OocHjKehd1fZ0llFMCIMjAAHMUl5NxdZoLOAYwYUDl9G+B00Qk2WWvM/Quykw2QZmAAwGnyMqz983I8TnK+AVIqdJysoTLaYvfOMCPPyWRsBjGPWOceAWAwQKnMu9iQ/hZQamIUGPFrALAWpgDuIi9ipf8UsMzWSVcFPvExzzoX0A62pVRlchPPtIQk1pmF+ih3uafLYchgSbU6bR2PeRUZ3XWgNo9AB0jwZ6gxYDIyMtiJdeDRsc5yck2aUEICAPsXYBKCgp/0wNBJSExscwaGDsAQ69yV+ANdj7gJYGiiU+rgg6c/qEwURCzVlmAZFv7rKvN4EIlJMqJO/3ITraiA26aNWq4mGRIAMOAaVZ35oxrA4NINf5T6f9GKpGiFqIpmoYmABrGESBoIKpLZVrGlZo5Qypy2I5GpN1cAGAYx0Cw05XWR537uz4FR/NwikVFVO2MARqIKXc/XpRdANVfV+hcIkGprsIUD5wAWsZQVXRWQomNgAPouCN6ILTq2Ikk3DRNL1SV8YZ0lzLrEJTr/slgjYtzRMeva+ALxdpbRcEAZAyMhVYh6PwAhA+NqJSSBOwAlBKZhX3cAA1DLuJJxYuqElJTpwICcmUMj32AABn++dPKzZqEZf64yrplgYKjadfqBFzIwEtdqqca+6LYGW5gvqztdAJyBwU08D51DbaeLVqEFCiqf7yzQRTxn6q5ELptHAODHxzxbmsXOcAeXupdQy9WUIAMQb48swOMrYWDoQNWkHAoARoHL1rvtF2LHVu0qTGJqwbhxAMYkEe2qJYw/b8Y3IOaZi35z9yncR76OQeMUYBfC5CLmE3EEw0IHP2j9Jft95vZ0lbG2AFgFWPvnQBCwyqgOwFh8EADwht5f8/MzEMEPKPxkF4jyNGDmYB3wzfloBwCJdf7ICjvCwHB9mk4gS03QXAXLZBPF4SYzbCw14aokJPxzCqmJZGBwo82sSrxkYAzY93kpp3iGaotAdwNW4GAqIiFxZbKgY2CIKiOdWEKi6ugRS9x5QnkbOYdp5zxLRgE102T5DejsPoljZA0eBzC0CU65A2uYBjAmaaMqxh3rQpL8rPP3oOlzX4QOW2tcVZJYX4RxuAqAojTckNIB5X3nAFvHW0M9IiGZRLIgPr/Pqf8pAI0QoDaPKgcwSG8j5ucwKd091WI2eZ/e/NP4wuz34l8H72eMDB4x9gEhoCsP43XGc6gdMMNN1i45WfFnbZOPBBfRHPFkWQIYUVYFm0OLzjl0gnUAlPuosLHFKuHtkwgMG6eN88jtnWF+MLUF9TXjYOkRso66sya9aSZlYIQtZ0NzVZlc5ytAoS6Nes3eVsyrIsZMq84AtQW82/8rlP0DYOVNACAlJLFxcwPNGfcCZulWOOYJQZfo8zpK3Q8GjhQPGXic610EM7BdTDOruNmyKQEM3nVJ1xKYS+yqQyGb25HrY9a4peRlUgkJAOxfACG8C4lhAXaJe2CoX1fImdg+ZLljJa9po5rwB8p9A/wvgJsAxjWFbdg4UjsCJ3BQsSuZJooASyBFwiKkDsloFRMVcG8Ey7CUm9tGoYFD5zDWqhMA3MBnCS8NUtT6ViHc0GcyMBQVyZE/Qs7IKalCqUqxFwUw4u0DM5OFrEQkSQV/4veBJ//P1DgAxNggIjyewFhAKokjhOCuDnOQPlo7qhwDEN5L4TtRy9eU1yNv5mNsF0DPwADUkh0g0jmFqo0ql2vL8rrrAIxGoQGTmKztJPf3Wu7jAAAgAElEQVSr0NL/E/cxy/dEMDtSnhkEyCkkTCkJSRabYAIGhs/ZJIRYuHyoblF5oyNqtHhs6pj2uJnyDDb7m2MNgJPrgTA9NUh66a7n63ACR8pMouFFGRiJeXRn+07576xKf6cUb9ur88tIStXGeWAA6vvsRgGMBANDXNsvrX8pUzLRLraxO9qFH/gTSUhUxsUqAKNqV5E38/Iz+oEPj/psvUuYHBNCMJVXA5RApI0qGQ+Q6aKSq0gZ3G2t2676PDfjGqPUBFon0Nh6HPcYL+JwmklQJTAR3ZgSgv02MxP38nVg+nQawDAMoHkM5s4ZtHAIg/qhB0aSnbBwP2CX8KbDP4cHM5YcA4ibeBoGUF+StOj8aIdVrQ2TARhj6MBmxAMjZfrIPxsaR7FCNlAebjDQhZA0kCKiNo8clxyYwguKt/vLZGAID4xxEhIwOcEUoh4YkzEw3CuoMoYeGOyap5gV5TZQmcXbvM/Bpq5su+moKP3Lb0DB3UODdOF07pDni75PeN4OLL4/shMSkokYGAaR7ISUhAQAjn5T+G8OlCnHUl8C8YZo4hCV4aq89sr7zpO4treOBhUMoGl53kwGRtS7wNfIe2rzKI82YCAA6W1zQ0WRUE4oIVF0Ickl5DV/f+yj+DX3vTHb/CRAYKy8ETNkDyc2/zOTZszdHan4E3kuNI5iObiAzogBi2gdh5PsIMRZPAvOWcz7XKbTPKb2GbFyGNSP41byMvL7Z1mibRhpVgfAnlG7jCNYxZSzISv441oZy7dKSUgSoF9tkbFyAJiDLaDcUbfABYATb8cK5SDOsUcAhOtY7DNOrQBmDtPOBcxiW863SU08lR4Yie4ixQMGYOR7q+waWbn0tW7dAgx2UfT2YcODObgsGWfRayOjMAXkaxLAMAY7MV8e3biTsjYgA8DgYA72LsAwwBgYhTpAWAcp3bpQsAwcDNkesawChBGXkCjXixsUNwGMawyR9B6bOqZ9wEXVfqO/IVsVahOWCMAAsIRFZdgnjgUUtGfqa/XuKQaGQsoC6E0odQl4q9jCwBvICr80G1RICXTJqS5ZABLAC3+PMg2AUdz8r2yXYRs2dkYqAIO9zraKSjDgLYtvAQDpf6KKqH9BlnEmwK51FMDIun5T+Sm1nwmXGNhIS0iAePK5VF1SntsgBlqFFutWwkEj3bh1AIYKWEqaqwIRxoaCgWGbNqq5qjy/TGwV0oKiVYRlWJkMDI8DY13XwBPntrXH3cgQc2gqPyXniiqmS9MTARjNQhN7oz34HIgcekMlEABk+4Z4UQZGYh4tVBakhOrBmQe1Y54pzaDrdrHWW4NPfX3b3sS8yPLAEOCDysCWSeGgHLOQTFzqXsJCdUE75laxhYAG2B3tZkq+bNNG2S5P3IWEEBJ7vqXUilIGHCeiUVADlMArw8AAgE88/Am8feXteOfRd17TeW7GNcaRN6G59rcokxH2ptl3iW5DvXryg9inJazf/eOAYcJJmngCQOs4jN0zmCFhm0BxzthxuZKsAn/FOA3Yhdh7pyquU8swBAPD2ZVmkBO1UTXCNqrKai4ANBmAURteksmq62vM4ySAQVkb0EIdMMyxhqJSQsJNPMuqiiFPasqjdUyRLgK7BFj5CJthjAeGxz0wrqQLiR8mvKnzH30LjgcvsX/PhsBE6hquhJ2x+tzANzQnTDIw2rD62wAobGePAWlgEpKJPDDMjDaqALD8BvyXqe/Bvyv+iGR3KOUY/FovkG1Uh2vSh8VT3XcuY2q7q5gK9rjsIzeRAWPYjSHQz7/aAsrDTTRwCEJ9LiGZrDIvItliNtVNBSyBpDQ0NQU4CBQFVfi9vH37LxiwmK+mK/4A0DmFRf8CFpxzrE1r42jaryJfBaaWMTc6i4WAV/DFcQpgZtg8jdPGyywR50l5CohhHxZoHWcAhrsRY2BMIrkRc1J2IUn6xtQXUJAAxjZQmdYDDW/+Z3jePIH/2PgQawcLzRpqmEDzGBb7z6KKfgx0Aa7MA8PxEoBAoQ6Up5EX8r3eJXn+FDOMs1dq/fOYBt/HV2f17BVCgKllVAYcwOhvA+XO2HHHWWHsmdKaHBfqQL4GHFyCSQiKQZf9jV8f3TMQBYErGhNPcQ8EE2QSf6DrETcBjGuM997yXtiGjfccf4/2mKJVRKvQwqXuJeyP9rWtCgE1k0GXsOic8z3qMw8CIOX10C62sdnfZFXUjNabKt12lgQi6d8Rk5DwxEFE0SoiZ+RSSYvOxBNQMzBKQQD040CFMKJUMjB4ZdqyCkow4H0n3offfNtv4p/c80+UYwCY9KJZaLKuDc6+lkkDxD0DAGhbhgK864sqiYu2flWALt+0yCojd3fu1l47gFX813pr0mtAVz1vFppKIEolGyrZJRStohLwUJl4AnGPDTFHVPNbVK2zGBgBB0h8asHE9TXxnDSO1I/g3z76b/Fbb/+tzIrFdGka6711eT+yWq4GNAjlGN5QCfiIYwG1/4sf+GwOASk2AwD85tt+E7/99t+WchJVCIBsnNGtZGAME12DFOOu5WqwiBWTyYhwAw858GuYlL1Ul2TCnyWZSMr3bMPWsrxU8831XeXcB9jnTLZULgdpxhmgbkst34Pfj2sFMB6cfRC/8sivaOfSzbhBcf+HQEGwRevYmmXrs6QGJ5Ky/vwbcffo32P19D/ix4mkJlHd2zmHE+RS+DsUJp4A8Mgv4Mn62/Brxg/JP4Xa+CSAsSSN/QrOjmzHGdDxVftowqtMhgCQxhEski1MDV6OyVmUG+faIgzfQQOHMEd7kkEQjGGDiGRjr88lJLbiGRIAxnAdLXKAgK8J45LZuAfGZJv0pA9ACmQCgBNvZ+eFzUxfoZGQtI7jmdt+Cv+z+70Y1rlXhq6iW56GOdxBDT2YgQvwFuveBGwadj4jLiFJjtkw8JnOj+I/WN8u/+Tylrix7zl+re8xXoQVjCRwpWyfaxeB6hyazhpadA+ozMQ+Y9a4o+1NlYALANTmURptYobwdTdi4jlJa9noe3kZ91O8tzDgBSCNDWW0T+EiuMT82CPseJEwm5FcoH0Sc94qjjhfZ6a8phVvlyxi+nbMDM7iJD3Hrlu5nfZlEGNp34FZsoti9+UYK0tZ5e+cwuuDJ2FRVwJMfhBMNIeSbJWUb4yUiVHk+htAZUbPwJhawj+b+jV8uvb98k9Kjw8AaN2Co13mAyfmn/Y50Y3ZV3QhAYD2CeT2OYDRX41dk9i5BYDROx/Ot9p8tn/I1ArKg0uw4MEY7jJJzRiJEyEElkFkF5KxzIfaPPP/IQQF71ACGAFFBgMjAmDoTDwTXhxKAPEGxE0A4xrjnul78Nj3PYbvOfU9mcctVhdx8fAi9h099RpQe0lkyQ6AdMLi0gByi66otg68AS4PL+PQOdR2HVAxMLIkEKLqmuowEaQTWdHeMJm0OH4GA4Nr2SmlIRU8oEA/XXnXmZtKCQmxlGCAQQw8vPDwWK+DldqK7DSRxcCItnAE2DXRAhiFKew7+7LSLsfM/UNsM6cEXU41T+FT7/wUfvWRX80cs5x/EzAwgJDVI0AGHVMn6dHguOx4lYmnPF5ICzJMPFXnTobHk0YKExZ8+QX0jY5Hlh4ZS+Nfqi5hb7SHs3tnYRBD20Uj6bWQBWgmgYNoOIGHnNiE+Om5f6R+BG+Yf8PYMQMhgKGVkGgYGDoD2+iciIZLPdhCKpOY+5Zh4XWzrLp93/R92jELH5LV7ip6Tk8pHxGRXDcopYwVpgE8ogCl8NcoUQo4vdSxWWDcK8XAuBmvkpi/F8+/7y/xLaN/Ccdgc17HgmAb25C+r6wytm4BCVw8an0FAYyIiaIiCWkexR8f+R/wLOIdSFLnBID6MozeJvJwUBptywQyqzoXHXe0a4WOgZEnHorevuxKom2Lyk3+5sgO64jCwZRxbJCwjSp7hpQSEn7uynANHezB40bckxrmiWrn1XhgKEGm274Tny59Nz7Z+gSrIAPqrhAAzp76Efy2/x0IqGAAaDT1lWkQUNxCeEW+1EIgq7mTjTuTgYE4aAWAt+JMzj82Nx81nmS/SwaG5j42jqDlrKKJPaDCEvxJqufRSrTSswMAavMwqIdbycvs90iCOCkDQxwbfT6T90kk6SM33LulfAEMA//C+DE80XwX8KaPAoA6YV58ABY83Ok+Jb0ulGDDzG1oDV/GvXiemV4SogUlesuPhL8cZQxRpYknEGP9iKR80k42dsSfgV2DhLlqbQH2aAcz2IXhj5gXR4ZkwjLDNQYIO8CkCkPcOBkAA30A+bxMAsSKz+j4ivvRugXW7hmY8FEarEkAIwUWTS0DhoVq96UQwIgyMFTXemoZ5f4ltMB9BisddScZxZi9YMI1qTYPHKzCMAjzE+H7yYBS6C5NdA3VmXiGayOXkKjMk29A3AQwXoHIqnyLWKousar9mKS3WWjGfC2yEhaVkRwAuAhCBkZCQiKo4l+7/DUA+iREsDuiiYXjO3oGRjFu0Ci7kNBAWZFMyisAvYknwJIiN3Bx6B6G1U6FhARAqhWoPD8HVQZOgJe2MtpzjgnRdnKjt6E1bgXCz0gpc8vuu31tAtXINxDQQEoK5Jh5MkTMAnrDoeqluG/mPm0HHBGLlUWs99bl/cliYAChh4jwU9ABGK1CK8Z2cfn4c6DKSn/U0yHLk0B17mT4PGmk1ICJQFbhXgtxjFfUvrj+RbQLbS0jKwUM+noGhkrSI8KhPmy+3G8dpBPsSUIAGE9sZne9Kdtl5g8xjK8FWfIzFeDo0ACWADAUc+kX3/iL+Oev/+f45uVv1o55vsKSl9XuKvZGe2PB45jkK9D7vwBcjsevtTBnLgdBinEG6D1uAMCjNwGMf2jht09hBzVZNRTV/mTyYyeqt8oN/QyTGbzb+Dz28vPSY8XRGLHZBknR2dk5kxR+9jwvkG2UnG0pTfEmaKMa9cBg/g2q5PRo6t9usnIpgncPmCU7sIdxNshkAIYDyyDqRNYuAqU2SsN1dMg+PP5dKe+JjoGRaBV4VV1IAkVSaeXwR1M/gifte+SfXJWEBKq2rJoKLb9eJwzO0ol18xg77JgkSGfKZybmlTKxzVeAxlG81fwK+50bdaZMD0U0jqAxWo0xMCZqoyrlCoG+AsyBq/sM3pWnvhAxCJ089YkzMGhqvuSVDIx0dfwZ6w780fwvSKlWysQTAI4/Gv575WF+XgXYMH0bDPhYIRuya0eq0xAP2j6FT7rvx0tHPyA7H7m6axb1Ollg/jx+QGU72ayIzlXWHSaRYHND13uMF9nvtTk9AwNMJuRGriljKSnGPBc+R6KTi9Z7IhHRLjOpLiQA0D4Bc7iDO8k5GNQL2W/J59q0gcYRVHovYVZK/eayxzG1DNvvh89seVrL1IuGbRpwJpW1VTmAQYBScCClZVk+R4UI00zPwOBro8eZIN8gBsarfsfkui4uXryIoSZ5ezVEoVDA4uIibFtfuV+sLuLPzv4ZLMPCqcYp7XHRKupseTYzYWnmebU8kay7oIxlAKQ6kQi9uAAwdGBKwSqgmqtKijRwlQwMhYREfM617lrsb17gaQES0b50s7eJntuDRblRpKLa2Sw0cW7/XOrvPgdzusMAX927jCPKdxofK7UVfObMZwDoO02IMQ+8AfpeH7Zhw6OeNlmXkp3RbowV4/Jrtz8ycf5gH6cpvap+y0vVJfjUx9cufw22YWcyKoDwPsq2v7puNcUmVrur8neHm9TmYCoZI81CE18YsK4pAsCo2JpuFsUWXj58WfuZhCTIoAYs4uNg6GH6NcKeFwDG2f2zmWyNFJvhKhkYLvVhUPZs/d1zq3jfVfg8luwSWoUWvrLFNqcCHEgGISRlFixerwo9AyOAxa1Hn355G3cmvHVny7NjmW+NfANFq4hL3UvYHe1mGn52ih08tfWU/F2sYVrwrtjC7mgXru9KyVUx4AwMSpnOlUe0LXXSgFUwMEzyjali3IxXPqJma9GfyY2s0KyHngkKucfsXUxSMdzDZvEYxAz2VEZ8YMmdl9j4AyqaNqsmniAXkfP7sgIeTNKFxJzAA6MdGhpj7m4A4O73ag8MAJgnl5EbXQbK3Nx0Qg8M16eoavTaAID6IkqDdVTIPvxiKK8AsvTm7NxD14cf0CtmYFBKmVZecW1sy8BgEFbslaaKiEslAEQMLhPn5PfuJOHGh+W2rEJPysCQgJTmftqGEWdg6GQIM7cDu+fgkjxszshQGkwCwNQKau4mSjBYZ5zIZ81KmpPtL5X3ns+pB4wXQIkJUp2Hy00vJ22jCrB5EF5/vYREmCoCahaLbZFYQu5wD4PYWHJlfLr9Eczvfgmvu+N98rjUdT7yZvlP/+S7YAJaw1vLIPh1/704cfc9OMK/kxw/iCWqMlrH8e+LPwyr0sIP5Zkv1+QMjHAtc30KShMGkxykvFcCGAtwueePar5ZJomxapVsJgA4+U4833oUf7wxh4+ZlhwzgLFAbNQDQ7lO8k4kj5pcosIBDOU61roF5Y1zOEoC+HYVZqkFb4/tUZXzja+/9xB+PaISp4xn1jYNDtxNIGurzQOH67DrPmdgNPjn1csEBShiGkS75onPI8BdHdBxveNVD2BcvHgR1WoVR44cuarE7XoHpRSXL1/GxYsXcfToUe1xK7UVUFBcOLyAR5Ye0R4XTSBny7OZCUstX4NJzFT1cgQgL4CARBIpnOoFDVxHXQfSHg5ZJpTJFpkjLn0oUMp6VSeiXWzj6a2n4+P2R1oGhqyk9lbRc3sogjB1vKvRm6vaqHIqO6gJCwHoVYIB0ZaFgtGiiqj+XujStUlcPrzvR+vhPBLGo0M/BwtD7PVdNMrjGT/JWKyy+/7F9S9irjyn/dwpyYKQkGQYyUbvo8MlKjm7BAzSFefZ8iwOnAP03T66fI6Uc3oGhpANqcYrGDWEEpgIMHBeHT4Yk8RCZQFFq4iBN8j0cBCghAASswDNolVEySqpGRgIYHIGRv8awOBbW7fi85c+j4JZyAQDlF2DdEybYgtnuc5Uhu/BIRSEsjF/8cwm7vwmxYvHBCEEC5UFXOxexO5wF8vVZe2x7WIbu8NdyQQT7KMsBgbAACMJ0tCAydN8J9aNRDCsDkYHKdmeADAmadN7M14bkXTk18k4QgozBzpUrQINA7j124Av/wG+Wn8rxLePLoG0TSNWKdd6YHBDunsN3tqRdzfxx7AegITkQEfhry/gD/EOHO3U8BCXkGgT2co0KDExRy6zjigRCUlWEmKZBgzCNN0llXxEjmURpYvPoIRD7EgJSXa1U9yD7og9nxN5YES6kIjzp/wLIFgyieqyioFBEgCGrsWoYGAIAKPUvDIGhhl6YCi7yoABCuL9AQWNXsTSQ8Bzf4q18q1YFgllhoSEgMImfswvQ/kZY+MNgaKRF6CtlJCwvdmtxgW4lUXYpiWv47juFNGIt5hNA1JSQuJFGRhpUMU2jRhLw9GAVn/b+SC+2PtW/D3fFzGPmcRx1Rl8+q5/h//y+HP41c7tDMDQgIOWNDyNg086wO8zpe9Cp5yHcNHxdfcuESF4F23xGXkmuT+FBDCqc3C29AwMyzTQc+Ign5phVcCf3/ov8TuXvo7/nu8VgzHPdmrMfkRCkmBgAMDbhCSKy/dc1TrWugXFM3+Dk4aBwdRxVAgZy8AAItejMg1/MP6ZtU0C15vQe6I2D4CiQ3dQDroxCYkOJBESkkre0uYJhBDkTAMOBxBzpZseGMoYDodotVqvSvAC4NXGVmssQ+Tu9t3y3wJEUIWouEp3e2+EvKXeQBvESHevCHyMCEC4C8bXLm7FXiNMKL+wxqrgutabAOuestnflL9nmXjmzFysw8SQ06XzlKZkLOJzivaGAAOCht5QW+2MUsG7ThdVIZFRyFOSRpQiPDkOAxY89K8y4Y1q7u9o36E9LtpyVSY4mvalIlFNyWr4Z3CCHCz4WD+4uuRTdG04cA4wV9GzRpLzb5yEpFloYne0i4B3XnC4pMfOlZX3Xcy39f56mNha6sS2XWxj6A/lcckQniaEGrDgo++kvR1erWEaJu6fYVXGaCeZZNRyNZSsEtZ7zL2763YzfRxU3jLwPbigIJR9MfUHVw9gPDDD2kIeqWcDyq1CKMfI6v4hjt0Z7oDScIMFbwAXRI6ZKCQkk8ZiZRGXupewN9qT0jhVtIttUFApWxIeLToAWbDCLg8uh52RRIUywQwT76szWAVuSkj+IUWagaFOnKJmaNHjU5KMd30SHzY/gSfqb5N/cjUJpG0SuEGagZFK2qpzADFxr6DYSwbGJO79hFdZhYmiGjz4X82P4E8XPip/1zIqDBN+eQYnyUVG1Y5ISMZVf0WSVNK0/AMA1BdR6Z6DQSjcoui2kt1SU1yvQ95ScBKjuigDI2z7qNH383sumBqqpFqwEEQipDWh5NfrlMHbb5ZaES+JyYCX0ANDbQ5oGwlPAp0s5L7/Fv8X3on/vPAT8k9+QJUdMgRoAQBoHePHanw+YuMV1f4ATtJrQUSpjYC3pnZ5AUfrIZIR7NqETKokICUlJF6cXZG8hjnTSDEwlEwXM5RnifdUzY3N9kP4i+ChTINRIGosG39vHYhjJu4zY2CMn0N2RD4lDUqjoB9nxDxkPAcKA6jOZrY7tSPeI+Lz6caRYipNYAQLxIEwV9UBamoF1C7hNuM8hvYUUGL7Y081ltZxmP4IrzeexaAW+odExxcLDmBIiVN5eqJn1jIMuFw6VRjnPcFBvKP0PPudMzACqn8GagX2zIwD+WyTSAbG2HFcp3jVAxgAXrXghYhJxrdYXZRU+Xun79UeJxI8ARwMvIG2+g2wjXHMJ8DtY0QIfJ99mT93MV2NPdU4JSvr4yQQ0YQ6C8AAIFt1AsCQeyHkc1VlItsutmV7Q4BVIX3qa5OFdrEN27Cx2l3FzmgHDbGwKZJbXTcGkZAYnIEhNiZXGpVcBT/74M/ih+/4YSzXsiu6ALA93B5bhRYeFkkAQ7QKdVCADR/7g6tL5BqFhgTOsir+BauAer6Ojf4GgAk8MHibStklgzMwbLMM0AA0YRgp5tt6dx1dt4uSVdL7P2RIIgDAlR12DJjw0XdfOwwMAPip+38KHzj1Abz7lndrjyGEYLY8GwIYTheVnFpyA2h8QzgYAA4GjJyr9wp5z/H34K7OXfjRu3808zjR9QZgAEbRKmZ2Xhr5ozhQ5Q7hkuiYR8rXThLLtWW8uPsitgfbma1to88rEEpIdIwXCVAOtkKQRrRQTax5AuyISvJEuPSV6UJyM149EQIYSQZGQkKSML7TmtrlSviqeQci+3meTCkSFoO1dfQjFXXVe8O0gPoCHiDPs995guFN0HVAJOUBFYmY+vhUMpSRhPiVedxhvMR+KYc+FeOM+ESrv2LWJroeFo2covBa4GPUfFZxvQ6G7PlUGoQmQjIwOI0++rfYcaYhQaYspkaSgeH6moSoUAe1S5ghe/CJDeRrYTI0wfbZjLbF1VS6o74nALs3Skp/cQqfND+MC8WQqeoFgVoSMhspAC2EsiEgm4GRNPFUegEYBoZ83XUrV9adIhrROZwpIfHC/YdqTElmlM5rJCk1UZqlIg7iABkAhhFeK3lOHZsBccAGGO9DI8KUaxmVa04MxLGLEkjqlpcB05bH6SQkXoJJpvTaQQTA4EWQUD41mYSEmXj6aUmPaSFYYK3l1+r3SFmokn3UDq0BenUuNcmShBSn4OSm0CBduMUOkCvJ8WdhBzmLzaOh66tlQNHga/pxn0vqIx4YuiV+rs72O+PSWtsywjaqE8jrrke8JgCMfwhBCMFvvO038PE3fDwmQUhGu9iGQQy5+T90D8cmLNEEzx8dwiMEAGNt9PpphsKdHVbxrdpVraQBYJtu0XIVAPpuX1tFBVjSIhLfHm8JWs5PaQEMIEzYZUtNTbJgEAPzlXms9laxO9xFw+OJvKbTBaDwBuHjYACGh+7o6qu6P3DbD+Cj938085iob4eo0Oqu91R+Chax0gwMztzwghws4l816AIAbz/C2re9ZfEtmcfNlmax0UsAGBoPDOl9Ikw/OYCx3eUA2qV4Mi0BjD4DMHT+F9FzqyQRAODyOSMAqdeShAQATjRO4GOv/9jYtpdRAOPQOcw8XsnAcAdwCAEouyfO6OrBgE6pgz941x/g0eVHM4+br8zj0DlE1+mi5/ay77MKqPIGcAkBFWO+BtDlttZtoGBrmJBSqUI8r9v9xJqkAVUF2LzaXY34fFT5+BPtq0sh2JGMV7wLie8Bf/tJYOfs+GNvxnWJlDREKyFRe2DoDB2jzAqdHMOSyV38vZUMgtYtMAkFBQEaR0ApzWyxFx2L+HxZyZAZoXPLMWvO7VfnMCcM8HilM6Dj24BWuf46U0LCtesAMJiKJxe6YqcwWBXfuZNUGVUMDCU9PuI5kcnUSFSWtRIIQhDUWTGlV5gFIvR1ZQcExfvEupAomQHxxJp5LqjPbZB0FV9plpqv4i9OfgI/434EATdYnqQLiZmo9uvYMYMyW+97vGh4NW1Uo9dG5WmSlwBG3MQz5YFhpj0wlEyXlNSEqk0uzTgwoV8PwmslQmcaC8T9UOR5JwAwooaYIYARf2bcaZZ77NVO8XEo2kbzsM20iaeOFSBkZmJ59HRAn2bMvh9oPTaCN/8MzgazeHLhg/Jvymuy9DoEXAa6Pf/IROPoTrFccFQX7KPx3h2iK85ExsIcwDjiv8R+lwwMPSg1ywEMAWTowuYSkqEbTCSvux5xE8C4gXHv9L14/8n3ZzI2LMPCdGk6XnHN2Px3SgmWBE/aA8oAjMN+OsH/liPfAotYeO+J92aOt1PqwA1cHDjMmLHv9TMBj7nyHNa7bNy90QEsSmHkp0C9EWhk4wVE9OMRc0JAnyyI8186vITdwQ6aAsBQSEh0dO0RBzAINWFz08frGfV8HSWrhEvdSyHFXMPAMIiBZrGJrX48wfG8qG+Hh8Ph1YMuP37vj3Bj63oAACAASURBVONP3v0nYwGMKBA18AYgIMgZauZNMvkccObN7oAdf24z7oPRKXVAQLDWW0PX6WbOp3EMDE8kiZTAhP+aAzAmjdnyLNb76whowMCAcYBmEvBxenAIQUA5nda9/t1aBFC11ltDz81uX5o0AAYAuAO4BBLA8K4BwLirfZf89/Gp49rjUqCqp2//KsZdtIq42L2I/eEeCKWoco2pjoGxrWj7/IoDGOf/HvjrXwL++n98Zc53M6440gwMnYQkNNVjx2VQqpNtLDUb+miLu9g5VSDDLHs2elYDsIsQpx/LwEhoxzOToUQiqzNnpNWIKTCXFoxrowpAavkrWSaevPsCAAzKzPtjXJVWfKYDznqcBMAghMAgbNyer6++WkZotKqkrvMwEgCGlyGvCKaOsPEWF2KvGXcvxflcn8LzAwRJ88XIMdH553iaVpxIV/GZB4b62Bdn3oU/9h+R1edx5qpABKQLAm3bVwA4c9fP4Pe9b8bucWaI6WbcE12IhJ5SCjdQSEj4vEhKSJLPhOgeIUIH/KkSdzVDQbAHIgwMxeeKGi5Gz6lkzyDdLtcPgokYGFYE1BRslOTnG97+vejSAs4uMNap7EJiKpgoEZaSGLN+neFjvUIGhhmRkOiAMPPom/Co8yu4UA2Z80rwzrTx/Lv/E37A+Xl0q2yfMa4byt40W5d6XJo7ybjF/JiIgVFsAFYRRz1ezCiO70Jy33IDP/HoLfjl992l/P8ihCRq5PoTdWi6HnETwHgVxlx5Dmu9NfiBj77Xz6y4TpemYyyJ4ZBVwN2AAQHuKA1gnGycxGff/1n89AM/nTkOySDgcpae28tkYMyWZ7E12GLtTp0DlIMALx7kQUDxwlo8kU16LYxz/AeYEeq5g3PYHl5G0w+AQp2ZeEa180gnIiIcrqMnAWu72b3OAAYhBItVpr8XIFBVVGgV0Sl2JH1dhOOJVqEmbFwbA8M2bJxsnBx73ExpRgJoA2+AolXUgm7iWkvJEzfmHATsPu4edFNj6JQ6WOuuje0KIQEMLQODARiEmjARvOYkJJPGbHkW24Nt7A53QUEz51Cz2MTeaE8mxQAkGBAEbIPvulfPwJg0ogDGON+OZAtmAJI14gccdLkGCclSbQlvWXwL7p2+d6IOUIIlIT0wNKwwYRB66fASdvubqAUBLM60SDIwKnYFBbOQWpOACIBBXiEAY/PZ+M+bccPDTrAgRJKRkpAoaOCq44B0ZXSc5n2cgSgA4DRLJJ5pMEbVpBXqMHmimQkkS4bCJETrhQAg4KaiAKQ+fDIAg60RzSxz61ITX3n0U/ju0ccRkHhFWi8huXIGBsDBiQgDQ3UvWRcXfn8CkcSpDBjj1PgQFFEAGLPMZ22rejr2mkn8KkWnDUnp15gqiu4qgGgRq6f0R+VOmcdqfD4yk7hI956s+dfr3IOPef8IDpdhyzaqV8TAYF0f/IB11kgmriLpjUpIRl66Kp2zEsyKTKZL8jnXzw0xJzyNxMJOXN/wnDowwIiDjhOaeFqReyI6siSBMP/EO3HH6P/Ay603yXEACs8fxFlK7FiNaSxCxkLKA+MK2qjqACXDICAknDvSs0Zxbrd9Gn8X3JUGHDXjvnTrh/Ax94ewdvuPxMafBTraXEIyEQODEKA2jwWft2rljIwsll3OMvBT7ziF2+azmcFRD4ybEpJXaXzpS1/CXXfdheFwiF6vh9tvvx1f/epXr+t7Csp412XJX1bFdbo0DTdwpZfEiFP4HZ5A6ujiQqqSFcKXQbAC+l4/MxGZK8+BgmKrv4Wuc4hKQHG2xzYVL67H2RBJ08qBn+34DwCnm6fRc3twAxdLnjD6oqlOK0ngRYQAMEAtzma4/qaPC5UF2cIRwFgTwWSF1pGdNixY8K+JgTFpzJRmsDvalb4EWQwgQaOXjA0OYPR9Nk8OFRIm0RVie7At54EqpvJTICB6BoZoEUxNWPAxeA2ZeF5JzJbYNT6zx7oFVHN6AKNVaIGCxuVTHAzwOAPDc6//HBKmu2vdNRw4B2NZI0ACwPCYB4YvGBiKTkZXEr/+6K/jU+/8lNaHA2BGxPV8PWVgm8UKE3N5b3AZDT/ALmFtqZ+/FGdSEULQKrauTULiu8BTfwy4Y0xYL/OuEglg92bcuEjq00WlMZn8RE3kosep2BKifZ4InQeBeA+RGDuywq/YsC7ej3cav4U/nf9xAJNRmNnnCxOGTENAQiByEEppJiDhLb4BAHBQXAJMtlZN0hFFMDCapezuXIdzb8Lj9FbJMhmXKJsGY1NID4wJAQyTsw+ygCMrCmBkSEgMIz4/Qg+H9LHBgx/Bb3nfhqfnP8A+n67lqmbMAowC9LIXIN7SVVdZTgJXWUlw0udjklaSIUgX6LvgILx+orKd5UuS9V5+EHqaJO+nACpGYxgYyYTc8QMN4MDApCAyP3TdhsT/Fz9V18xMzCEx1mz2TJSBoQcOYq+LyOZ0EpKk7EXZ+UOeL9lNKXvMYqzRn5N6YIxbx6wIk0yy1Ca41uMYGMjX8Pv+2+Hl2L4hmGDcooPR0J3Qe6KxwsYEM9Yq+woeAfU4OKPoGwlgvKZcw37xPz2Dr60evKLnvG2+hn/xHbdr//+DDz6Id7/73fjYxz6GwWCA7//+78cdd+g7T7wSMVuexV+d/ysccjp+VgI5XWITcqu/xczwRuz6DHy26XauoXIZNZ5zfAde4GVS/kWitdZbQ9froRoEuEwrAAF29g9jx5bsEkpWKdZtBchOFm5r3Sb/veK6OChOoQbgsNdFtR5W8m3TRrPQlEm1CCfwAJig1IBFAgxuQMV+obKAx9Yek/T4er6uPbZdbMv2tiKGPIkCBzBuxJilkWxvEwejA9TyeiS2aBVRz9cjjA1mZnjoVQETOOilAYzjU8fx2fOfRUADPDT7UOr/i7AMC41CI4OBwSVBMGGSAAMnUB73Wg8BBjy9zdrVZs2hqOxGAJBw+3AJgcONfZPGqtcj2sU2LMPCam8VO4Md3NXR0xGnCgqgyh3AAYHps6Qk8K4NdJnUCLpdaIdr0hgGBsA8Nb60/iU0jBymggDnnRIaAJ44u4FT98ePTZoii3D4PM4ySAYAPPn7wJ/+U+DtnwAe/kn9cX1+HRVylZtxY0KlTwfSG/WwC0ncxFPngRHtXKHrDiAqg0kGho5+vW204XGz3Emr9mH7wewEUiTzQHgNdJV4zN6Fn3D+O7ztoTdB2Br7wXgwZYoDF+Pai4sN+xVV+k0jwsCYbJMukh1t+1rwTgITSEiipqBApI2q4hoa5Qb+F++D+Jkcb0F7BQwMIfmQ80/JwAiTM8vUt35l7xkmfOFc1QNF0fGK12UlWOJcDvcu0EoLJDgC/pMBKVfSGEDeTw2LSu2BkWZgJKUhWV1IAAZA5oih7VCTBD91Hg5RtoqITN8alexrQhBMHC/bqCauQbJbSDZgG2/bm80a0QAYVyCFG3d+P4ivp0q/kQggAoxnglwNc0R0qWFzbAJQtXMaOPPXuGx2MGOE6/yVdOJRRbTN7UTjuA5xk4ExQXz84x/HZz/7WTz++OP42Z/92ev+fnPlObiBi/MH5wFkV1wFgCGSdQFg9DiA4V0LgMEToPXe+tguGgAwy/vIr/fWcej2UQkC7ATs+INuulvIdGlajlsY5mVJSE41T2GpuoSikcedIwfPHbANy/93diN17HRpOlXtHFEXFiUIYN8wMGCxuoiBN8CZvTOo5+uZVdZ2sY2d4U6M/u9IlgEHMG5Akj5TZi7t6/117Dv7400mS6HJ5IB7ffQCBrr1++lq8S1Tt2B/tI9D51DOX100C00tgOFx5o1tWLAQwPH/YUpIhG/DY2uPAUDmNVPKpzgDwxFggO/GW5ZehzCIgfnyPC4cXsDl4eVMqZBtMMAxxpjyhnAJMOKgi0G92ObvesV0aVoa2ArfGp2BLQAsVZfQ9/p4Zu8M2r6PDU+/3nVKHSUDwwkYgJHFPgMAbD3Hfo4z5xxw9k1/J3Q1uxk3NAghPPERSap60ys2zBJsGJPMRpMVdpy6gsuOGe+rAbAEN0hs/MeBBnYkecqi8EdBF28MI8AwCD4TPIzNSmhyHkxgICikF4sN/XMqzg+E1XiRMGd91pxpXJEHBsDo4n5AMxMdO9JhQZcYA+nkPgt00TEZJmZg+BEGhrKtZSgbEj+1spCIiWgoSxpnwCiOD2CNARnEuYTvlZ6BgdgYtG18M0Ikr+IZ1nchCeR7+QFN+Tow6n8CwFCMO/SwCUEwNSMm/px7mra2QgIRBwP09y7pX+JPaOIZXctkG9WUkWmCHZbFwDCS7WT1QFXq2Z6QgRG9Nq7GLBVg8znJglI/r4i9/zg2kQQwkmvSGP8X50oYGEffDAA4bx2Vf2IMjGsDMHImQZez024yMCaILKbE9YydnR10u124rovhcIhyWZ/EvxIh2l0+sfkEAGRu/qeLLJkRm/8hBxoOHQ5gXIPevWgV0S62mQmlcNnP8sCIMDAO/QEWgwA7lIEvh4pK/HxlHmtd1m1F0rUzqp0GMfB73/p7GDz/Fyid+TGseyxJvrC1lzpWdFCJhkMDmDBATAtW4GN4A0wfRcvSL6x9QSaXuugUO5L+L8Cjoe8wmDGwYBnBDZFJCP+CS91LOBgdZLbaBeKmn0NvCJtSDCmXMDlpACPqw3G0fjT1/6PRLraVVWsAcAMHQBGmwQApobv8hxatQgtT+SkJYAhmlCpEm1CRhANgDAwQeNzY14Z3Q3p3n2icwFNbT2HgDTKlQgCbQ+v99fAPLutCAg662BxwHNeb/FpjvjKPv7nwNwAQSvgyGHC3t9h3UtcfYNH1sOay74Z+Pw1gtIttPLb6WOrvgoFhcwdzbXT5erZ7Pvs40UaX+oBzyLyCbsYNDyuiZZfJbGJjavINdBRsMIh6421xann0fFmV2VQL14zNuTS/G0d5luOOJCtjTDyTevBxlfgotupNYCD4Y4+eQL2Uw7vuzP6eSnYqmIiubYUMjEklJCEDI5sen+xQo2PdAHHZBoBMs8YrrUJHx5zlgRFl3YifVl6dQsRaj04g1YmOdxKQQcwhWQHOmNtAmNiyNr5XlriJRDpMXBMSEi6TGPGCmE6Gk0tIIhw/QC2XXvPl8+sFECPV+aiwzxT1wFBfB9sI31sHsIhIMzAmM/EUh2R1IUn6dgjAdpKuN64fSLlYaswK8M4gkzEvxdx3JmRgCDaUWq5zZQwM8ffUmjQGVBUynYn2cCe+Bf9b8xfwBeNu/B7/0yvBwLBNQ8rrbjIwXsXxkY98BL/0S7+ED37wg/i5n/u56/5+t/A2X2KzK6ngimiX2iAgMlkfjZhUo8eZD/QaqdeLlUVc7F6UDIwsCUnJLqFT7OCl/Zdw2eujHVAc8kS220tv6OfKc1jtrQKIOP5b2VXIdrGNJcKSmjUOYBwcHKaOE+amMiiFQ31Y1IBpsYR3eAMYGEL2cuAcYKm6lHmsqtWiYGAYhF2XG2HAOF/5/9l78yBbsru+83Nyu1vdqlev3trvve5+6kWtbi2txSBkDFrAWGBg8IQFRg6EQcbyjGOIYYixGA0xE+FgBsJ2xJhROAhixgg8NtiE1wiHMR5kbMIGtIyQkFotqdfX73W/tfa6a2ae+ePkyTyZ9+bJvFW3qm4/6hfRUfWqszLPza3O73u+ywN4jsdLWy+xPbJLSKDAwIgGNKVknGCj4ykAxtNnn06/f/MZuxzrfLvQ2BqVMjCEkpCYFM77qYQQKQvDd3wrGKBTXkz5lBz1GDmCUQJgHNW9//jq4+k4tCyprMzoXgA57tN3HMZSAZoe4ZEAjpeWLrE+WKc37rEz2sFzPCszwozEvjoepwyMfn8SsD3bOsvOeCd91+kaRkMCJ6iebO0l74UqaUjP8D8Z7pZvd1KHWr4pE4jV6uG0a+wbjU0VjTldbdWTaAsFPUxXOe3SDcfJok5nNb8bhhFSlstTPEdMsAfKjfjU18hAMGxmc7rOdhv81Hc+XgluFpMKMomFja4tUqZm3ahA1xFERsM7lYHhKHBLSpk2cXViVG2mgEIoMGzWVWh9bO0DANMBAb8gWRiVSBvU/sQEq8dm+AnGdbF4a2RjUcftJQs6ZQBGUWZRNxK0OL4wSTsx96mrKCFJ5ROFMXnOZIyqVUISVfmoFJ/zeHpULXkpl804U49zwgOjxjkTQiRJSXHpOSh6RIyiCM8RU59x0ycGsHpUFNN6ZmnQPSe796cZ6aqxGOCxRcblFT5fVAHa6h/P8sx6rmAUxqUxvJMHcfjM0vvZEtk8vk48dVX5rpMGIZyYeC5o/dqv/Rqe5/HDP/zDfPzjH+ezn/0sn/70pw/1mBc6F+j4Hb5090uAfcW1SL/WDIy9WDEfhByniPl+6nL3Mtd3rrM5UCyH1Ua5CSUouvvXNr7GRjzktHQZoVMEJhvZi52LrA/WGYSDFCCxJSyklchkXh2rbbem0LXPt8+zPlhnrA0+wwEjIXCkg+MFeOJoJCSrzdX0+tVhG0Ce/j9IjEeDhJlSZso6z/Idnwe7D/LC1gtsDDasngug7tfN4Sb9sM9O2KcrhQFgTJov+q7PL3/nL/Nz3/pzlY3t+c557vbv5lM1AKRkLNW58dyEgRHenxISgHecewegGmybDMl3fM60zuQAjDBhEoxSMOBo/F9yzf2y/d43WTwAw8QMdpyYER/V85qajyYxv12/awUWml6TD179IB0n4D39ATfHCuAdDibTn0rTkaJRtf8FwF7ye711+3b9dUjkfIxOAIzjKt9zjJXGuLRxD9wsUtPGZjBjVDPqdfkkWjfGY4ssAJLmphA/WAUa6M/Sq6Dw57XjdnZHUQ+uv5+14Swrp7AarxtsG5XaXEGuz8AoppCUN5+RxVvBHFtxRbe0UZ0i3agbgRlWeGC4BS+F0BLFaSZZVEmH9sPA0P9/b1ghISnIU6bGX1aUbqTLmDL63xrgKGNg6PQIXco7ZvJzpvuLMtBkqomnfs4NBkbZO2YaG6z8fZCXbswiu9FSJM2GLZ6DVFqXMs5sUbxOkvyS3RdVXicmEFAfwBC1PDCK97PNMDWeuPfLwWOYjH+1vZN810nv+7qgqiOyManx1fcFKx2H57AzPAEwFrp+5Ed+hH/+z/85AK7r8od/+Ie8//3vP9RjCiFSFsaZ1hmrsSXk2Qa9xPizFym0zT+g18Pl7mVu7t1Mm4tTzVPW7R899SjPrj+LBFbxrCvxulm4uXczixm1+H2klQAYWp6yO4WunZqbajbDuM9QCBzp4rjegc/LLPWXnvhLALz3ynut22n6v2YzAAzjMa4E31MNznh8sDSGunV15SpfvPNFBtEglQaVVZpEsneL7WjIUiwYJdc9KklM+JYHvoXve+T7pv6/4r5jGU/KSKIRGtLwHR+X+5eBAfD9j34/a801PvymD1dua8bgAoySJnYYZ2yG/hGwGd598d2AkqI9ftoe33u+fZ6d0U7qOzFIQJcwbhLhHtnzemnpEqDkUzvjHWt6iq6f+9af47cf/StciCKuDxXgEk+57w8OYCSMst698oSRcKRAiySG8oSBcXxlrrgqv4ByYMKUkJRKPRyHcVGOMa2x8fI680oPjGlNb03zuyoAw9SxV3khFCf/+ncOqtXWNdnMVstlTNCitgeGo1NIypkHJjPABjAVTQGrQAnHZLzIenKgbMymB8bkZzVTJvTYy66luYpfFiGcHnsK/b+q+dT70pJaG4BW3PfsEhL1WcoYNY4jCNwsInVYwmIJ6pp4epnMoiqlQ28HdnDGvB42c9nitjDbOdPgXdk5UOPOwACbf07RCLksThamX+e6DAM3MQu1GZuaviA2b5vSFJKKez9jK2HdHrSxcOLLUxWjaowrlvlrelA1buAKdoezRUzPu04AjAWtb3lARYqZfgFldb6drV7uJkyGXsLA8A/YrFzpXkEieebeM4Ddj6M43ksySBvZaQCGbnxf3XuVndEOAmGVqKQ13EE6PjuobcfDyX1r2U0qI0liGYV0cVwfX0QMjsgz4aNv+Sif/ouf5p3n32nd7mzrLJ7weG3vtfRnwzhMZS9wsFSZWeoNK29Ik1MuLtm1xdoj49XdV9mSI7rSSV3tD2IiC9NBHSDzSEABGB5ROvm6H+uh5Yf4Dx/6D/zQEz9Uue35zvmcHKOfgJojqZ6Xo2IztP02/+z7/hn/8IP/sNLfwTSOBRgYDIzY0Qa2RwdgvLr7qmJg1ABUfcdnOUl2uRUpwEOGw1wjBpOfUdcorgFgRKFiXnhNCAcwnpSoAKmB525LPZPP3Xht+nYndehlSkNGlsm35zqpzGMclpvr+cYkOrQ0IcXUgSoAwzEmt3VX7fVqen8cVuzbTJeIrftOG9k5T7SzMU/3iLCxTZqB+jvmOaK2/47W1IeW8+4bBoxjixyoaEI5tqz+gjqHphmm2kc9BsY4ytIjbDGq5n1lY4KYQAdUr0JrH4A6qRf6XGkPjDI/h6JJ4riGPKVYmpFgY0MEnpOyDsp8RIqeDmXNe15CkjznU5gaqVdG2ljL0utheq7YPgfoht5gYET1Ukj0mMLIkJBMaWx9A9S0xrkWzYhDe+oNzAaCpcdJPTDKQWaTgWGLRs3Gkb/3q3x/9OnW18jOwMiAg7oMDCEE5nRkXh4Y+lV9wsA4qVx96PEP8e2Xv52/+pa/Wrntpe4lru9cR0rJXmK2GSYeGD7hgZqVB7tqJe/ztz4P2CMcAd7zwHvS76/E7VRCMq2RNRkYOyO12umIGrfkcIfQ7zLU8pTh5GReN74pgJEwMIR0cTwfj/hIfABAvTxsPia6XMflfOd8HsCQIR4Orq8anOiIGBjvOP+O9Ps3rLzBuu3DKw8D8OL2i2zHIW3cjHlzwPFqkGvCB2PcZ5y8fwM3wCW6rxkYUJ/yd6FzISfH0ABGFDeIhGIfHdW9//jq47zx9Bsrt9MsHw289BMgNpRNYuEfGYCx1lojcAJu7N5ga7RVjxEGMNpDItiS6r0bELJbMNzVQJ82LtalPTCs1V8HJJx+JPmlSd+fbDv4al8x5f7jlyoSS07q0MozYgBDCz3ZXJmtpDEbgAhUrO6nspQKD4J9yA7qSkg0DVyNp0JCUpjMw3wm2un+RX7/cQ0PjFbSIMyywpimVqTGreVGq5q6DiXXUjMwZB6UKF3RdYQRGar3UYeBUe2BkXkuVEsW8uatWvZSdl8n4zWkPVVjzhhA9RgYph/HNP+QqmOZDIxpbIiG56RNe3YOCwaWBQZG2Yq/Ga1sAx+nAZU2VsUkoGnzwJg9hSQ9TpxJSKbdR67xXhxH5T4OxYSmKoAB8mk9M3lgJABVHVaKjf026YFhl0/pKZ3ers47yXOd9B1Wl4ExKSE5OLPNPFfFe/2o6gTAWNA62z7LJz/wSd514V2V2+oov/XBOrthDyElYUIX90WUTjL2U288/UZc4fLV9a9yvn2+1krqT7/rp/npeIUGbUZSSwkmAYxz7XO4wuX6znV2RjuVcZ1pDbYJvQ5Dqf01pu8bsnhZ7YEhY/dITTxnrYudi1mDIyVDGeFKBz8BMEbjg5my1q13nn8np5unudi5WOndsdZcYzlY5sWtF9kipC39lHlDNM7REWetqakaAGGfMPHoVgBGzHB8+Aktr4c63z7P7niX3YTFMNCr9XGAdHxcjo59VLc0O0E/rxrAkHEAmoFxBM+rIxweXFb+L3d7d63+Q7ka7SL9dgqqBozT9AJd3aBL1+/mAEqAcTSuZmAkCSTrTcUQeenGdGNb7Y/xSqzGvb09mdB0UkdTfg6YKG/2fFfkPTAshoRFHfbUxiaNKswaljIDUUhkB7rprTGBhkkJSWkKhDOZRmHzIChOtGdpRKpK9xAZ2yQZo2UiryUkswIYyjMhaXinrp5nMh9bk6rHXIzPLWUzCCNxo8Zqri7fzRtVWhkY6eqyRbJg+LXoe7s8iSEvk5klhaQaQMs3tmEsS4GUsjIlBjAdPAo8Jz13ZQaWmpGlPR2UhGQKQ8GQTthibYtApQKUqt8dNp8TKEkhqQn6aMnYKElTmgZ8eEYiigINyt+LkDFMwrjcZLPoFaOAz3rXOXtep3uSmNuAIcGZ8tmKZqL1GRj130nmvTCLsbApIYnlwQEM8zmoO4551wmAcR+UTrd4ZecVdsMBbSkAl0j4B2ZgtLxWmoDw4PKDtX7nI099hI8MoU8Tkol5PJ6kVPuOz5XuFV7YemG21c7hDkNvKW2Sw1E//aOg61TjFC2vxau7KuWE8YCeEMjIx/XUiv1ReWDMUmYyS+rbEbt4CYBxkFjcWarltfinf/6f8o+/5x9XsmKEEFxducrXN77OOpJuHOAHWWTn3gGiX5eDZVpeK8coAGA8SCUkgZ8AWScABmCAPkUwQAbgJH4SR8BmmKU04KilQoMkVpnYB9dXvh1H9Ly+8fQbeXb9We7078wEYIReJ2WcNRinOlWzLixdmM7AqAIwkgSSz+8oE+X/+OUXp2+XMDBejFRSzXhvq974T2rupWn5gDWir5hCUp7oMRmjOm1inE78w4x6XdYkgFoBn8XYUv2O9iDQFP7yZigurlxamlPTUBRm07JXVdFrITMsLf+dVqABjPpTZd282xgYuvlRDIxyMCplYCT7stHXIc980IvoNj198fdszW1RQjIKq1IvisBVXQ+McsPbdCxaQpJQ6cvuv4mGMqoXCZo7lpM38Zx2nRQDw27iqZtvfT6GFQyMXAqJJRUmBSpji0zNMFWtMvE8iAeGbvSHYUzDc0tSl0wTT5vvRIFhYmFIFONIo6i+9MwzACrru7fg5TM16npCylJTNhcX3r+WsZvXoi7zQYgp79UDAsPmsU8kJCe177rcvQwoAGMvHiYABkjHP7AHBsC3Xf42AN5+7u31f2m0x65s0WgmTBBCelMakEdPPcrzm89zp3cnNbmrrOE2fZHJU9x4PLGiLITg0tIlbuzeUD8I+/QcgYyDhIFxNEaGs9bFcqQpwQAAIABJREFUpYvc7t1WqRvjHoNE9qIBjOiAsbiz1PnO+drX5OrKVb5w+wtIAd2oSSNQ1z1gnE4y9lNCiAlTSiAnIWkkJrfhEZ6bRa5UdqPBgJSB4UPiF7Jo4F3DbXC6edoYswIwpAwQrn+koMvjq49zu3ebcTyuJf0CYLTH2G0T4xAJl0BMMjAAHug8kAGU+lejkTWqFUgBjD/uKQ+iV2/fmb5d4oHx9YGSkMjR7n3tDbPIFXiOsTpqmRwbBoB2V/682SdMb2zSib9B0y4zBoWChKSm8aM+hl4Bn8W93zZxdgwPB0ioznNiYIhUQlLUspefm+a+GBhO4oGh/QvsBow2Sn9GjVf/rvKTMAGgWRgYntF4Qrn5ojkGmzGtN+W6l/p2FHw+6jAw9LmqSiEpNog249Gy0tItmylrw3MNBsb0c2gCE1KWx3am24WZB4bN4DWM4iSto/wc55I/wnLATH1ep8DAqN/saibPcByVrsqb4JZVtpEyUUwWWz0ZUiSl9bkujkeb6dZ5j9mArKKJZxUDI5PN5d+/1mhn476qC6y6QuR8v2NZ771gK9Pg+ERCclL7rktLlxAIru9cZyse0UkADNz5aMd/4q0/wSe++RP8laf+Sv1fGu6yK5sEDXsj+8ipR7i2c41Xdl5JV46r971NzwAwGozZnrLaeXnpMtd3r6t/hAN6joOMAzxfSQ4WUULyQOcBYhkr745xjz3HQUQ+QcJoOCoPjFnrLWfekn6/FLVoNBMGxgElTDDp6QBA2GckBEhBkCS0hOFinpujLg1gaKlCP/HF8UQDccRshlnqSvcK13fU89qPEmPe2FeeNeLoJF9vXntz+r1mn1XWcJeRoxJIpBMoD4wpAEZOIpbUKB5Ve2AUGBh72xvTt0skJF/d6xJLQYsBt3emJwGd1OGWycCwSUiCYgqJJQpxIklg2up+wb3fph2HvImnbjbrxqhWpUCYeno9djsbpLD6K+cXo1qka+vmwrb7dsLAWGqUR1cXS3/m1KfExpKpkJBMmAJGMZ4jyuVABgAU1wSj1HGUIZ9+x05nYGQNs/pa3lA6YtIzoFz2MgksVY05jVEd6RSEeuaO+vzNUn7CfBpXmXgWPDCK5zAzpTTlRXYJmD2K12TxaECz7N2RgRIjC/gJ82RgWBhnxliqUkjCWMluxrNISGJpZTHkjqM9MCxAr3r3Fow5bZ41NT2Fivd+FUCpxjs7A8MRk/HUBzVH1u9GmI2hNs86ATDug2q4Dc61z3Ft5xp34xErsaduLldNpKcxH2apltfih574oVqRgmmNdtmRDRoNNakPRDh1RfKx1ceIZczueDdtvCpruMMubQJj39v9SQDjUvcSN3ZuKHmJlpDEDTwtORgtXsNrJnow6rHrOBAFBgNjNCGXWYTSqTkAp0crNBoG82Z4sPvvfPs8N3eLDIyBMmWNPfzkesYnDAyA1KvmlZ1XAOiHqoFtei1wvSM1sJ2lHuw+yLWdawD0kjH7TkOlBnFwIKxuveP8O+gGXRzh5IA5a432GDhJgpLXICgBVS8uXWRnvMPOKDPhrCshkY7Pq1JJQ4Z7W9PfA/11pBvwyp5gIJq0GXJ752hkZyeVL9O0z2aw57tOnpZvWRnVjY9uIqdNolPzO4OBUcb+gLzBX2oiN6cYVWeK+Z1Nm+4W3PLDOTIwsshCkq8SR9jNkVfb6rlcadm9v3LHSc6nLYXEpMfbmtmMkk7ytRwI08cumqbWWT33CoyGaY1R0aDQKllwJ41h60Zg1kkh0cBdVYxjcYU7rDh/U8eX+EdkEii7hGRYYuIZGIwCm1QnMBgYNrPeDOgwQLAaDIwshcQu/5Gy/vUwxxRFCsCwgZrmWMpZPJMMk0oJSQ4Em42BURZrCwpoqMMo0o/apHFxFUNI/VuDj7b3r3kOTBDBVo6Y4oFxwPdqKzhhYJzUnOrRU4/y9Y2vc4+IJemrFQNXSUgGRy2ViCMY99iMGjRaCchAmDpGm/VNF74p/b5OZCwAg222ZYtWW+97zPYUcOTy0mV6YY+N4UbKwIjiZmqIuYgr9jqy9LW912C8R88REAcEyZgdGaV/1BaprnSv8D+886f4mbsbRFGbZiId8oimXvdZ6tLSJe707zCMjEYszFJlNCAVhiceGKDSbC53L08AGG2vpRgYR8hmmKWuLF/h5t5NhtGQ7ViPuZuwRo7OeNRzPH79e36dX/+eX58hhWSXvmgiBAivoRgYUxhnD3RU8pJp5FlLQrJ7h3FzjV2p3nmNuMf63pT3V2+duLmKlILQa9FmwGZv8d5zfxJqIl2krLlwhSEhsa9I6lXAUY2VWU0Vt7E6IFktnzlGVa+AV5soFifzZb4JoFz5cxPtOXpgpI7/Bl276nNqAGOWub6XMFqyeNQpK7VGM2vzM8lWlg0avaUxM69l6vFRU0ICWaqHNYUkkpWSBZ1qosesfman0UczMDAcR+AIUpZbqYlsoUEM9xGjmjFqyoEm08RzFE1/JnLeFhZzTs2iMLebDoJlDIzQcq/pn8/igQF5FsFsDAwVo1rW1JpsEHsKScYks0UN6+MWx1z3MmceGLLee8ySBCSEyIGI6fu0jDmSHC4ubm8ZvAkcdGoywxynKCE5uImnCZ50m/UZavOsEwCjon72Z3+Wv/f3/l7670984hP84i/+4jGOaHo9ufYkz20+xw1H0okadJsewg3wxMEbyJlrpEwDt6KAluGBMW1Cv9pc5YNXP8j59nm++eI3V+9bShjusBU3aTfVimfAeOq+tTfIjZ0bjEe7jIUgijIAY7SADIxLS5dwhcvL2y8rBoZwkHEzlZAcZSM3a/3o4z/ID+/ssB35NJsmcHWwZvly9zISyY2dG9kPx30GQoD08b2j9wdZ9Hqw+yDXthWboR+r+7zttxCpL87i3UMPdh9Mr/NOAla1vSWE6xOIo/XteGj5IZ5ce7L+L4x26ckm3YanAAwxXTKXApSGjKQ37tH22/b9792hH5xmF/U+XaLPze0p0pD+BuMg8b/wO3TEkI29k+fiOKqYGlJG7y6mldSJUc1SSOwrs2qf5aucer9F2UG1B4HaXyo5qKEdrzM5PxIJiWGYVzWJX1tKTMhnID2mmvq4RvNpygRqMTDsJpSOg2Gaam9qi2MGw1PCqu+3J3LocRevu80vw9yuLuvGc51KBsZB4jXNfWiPBLDFqNpNPDNvC9MsdRrTRW2nYlQt7BwTELFEe6p9TotRLXlmi14nMxifanBiOLYZYuZTl2zMND1eGxMFphnBzsbA0Ka7VawUqI6Dnpq8ZNkWDBPl1Fi4/HyboEWncQAJyVw9MI4HSjge2GS/9W8/Djf/eL77vPAW+ODPl/7vH//xH+cv/IW/wE/+5E8SxzG/8Ru/wWc+85n5jmEO9dTaU8RSPeQrUZulpo+IfQJC+kfd8CYAxkYY0EoaWZ8w/eNYrF/4M79AJCM8p8btGA4hHrMeNWmtdGC93PH/0pKKHLyxe4OHhtsAjON2mpCxiAyMwA243L3Mi1svQucx9hxBI2rSaKiJlJ+sns9CaT2ySswiN8M8cHWQFBLIp+y84dQbkmMpBoaMffxAnYsTACOrK90rfObmZ5BSsp2AAd2gi5A+gYgZhIvHwHiwq1KOru1cYzse0USwFDTA8QicxZS9pDXaY8dpsNL2EV6DRokHhmZgpObCQC/s0fJa9v3v3WHbXaVPA4lDRwymMzD6G/S9FQDc5hLt3QEvnzAwjqXMuMBxFJeulk0wNUpjBR1jYlxvZRZgFNo9MHLGjzVlB1nDa/fAcA1PhnGNhtocS5ys8s9NQpI2C+rfdZrZx8936TY8fuRbHqp9HL1aazNLzNgMdqPGLEUj099bPUQMCY5uWOqstOrrtzcM8V0x9ZynngSRTO/Deg3fbEkMUVzPp8JzRLo4UglgaN+OOKbjz9b26Obf5jNRx8QzZd3EMSL502CVkEQSKcufc9MjIruHygClyQSjyujZfTAw9LkKkaW+CDk2SCit5sagrllYMeZpMqS67w3fUewZqymtKxiO8x4YpQCQMH1/6vm/TDDgLM+s+XekrjePGaMqpVQmnnOUkNhkeIdZcwEwhBD/APjzwG0p5ZuTn50G/gnwMPAS8CEpZYnz2OLWww8/zNraGl/4whe4desWb3/721lbWzvuYU3Uuy68K/1+dbTM8oqHGOrV1qNmYOwCsD72OdPSLInpEhJQN78nat6KCRBxbxywlOy7IaY3CxrAeGXnFfaG6tYbxR2CQEe7LmbDe3X5Ki9uv0h4ZoeB4+DFrRwDYxHTUwADwPBZas3PA0MDGKkhK0CoPDCk9FJ5TXQiIUnrweUH6Yd97vbvsi1DgthjKWjCWIEBi3gP6Zjml7dfZjse0RKOWmFwfQLRW8gxpzXaYydosNJSAEbLCdmdct+faZ2h7bUVwyqpugyMTe8tBJ5LHCyxFPa5tztdQrLrKJDEb3XpiD02TgCMY6nAy8w5bUaaOQ8My4qkpmfr/anfndJoetnKpf5qSyExjR+jmrID3dCkJoqldHFzJb7cQ8Aci5T5sRynhORNF5f50v/6Z2eaoLuOkzT5MUJMb17SGNVYWiUk+ucmwGRnYEzKgeo0n/qe2x2F5dT/NN3GbmgJ6pqFcbHhs0tITBp9Ld8OY5tmlYQkAXVmSdRI96FNPC3MhTomnoHBKNB0/unPrwaKYuLEkH/adqZHROqJY5Gp6UWL7N1RLv+BfJJGmQRi8nfVdY9iWQoq+Y5jvBfL303TJCRlYy7KkGJZ36TSdUTam9iTWdT5qwLkFIBJOnYof4elJp6F96/tHu0aoEWrZjqSMDwwNMB50PfqcvP4F1HnxcD4FPBJ4NeMn30c+B0p5c8LIT6e/PtvHugoFqbEYdZHP/pRPvWpT3Hz5k1+7Md+7FjGUFUrjRU+/q7/kRc+/bMsDVdZaniIMKDhxEefODBUBnUbYYOHkpX4QEyXkMxcgy0A7oybnOoESDegEU6PLGz7bS52LvLc5nNsDNQkPoy6KRggo/Fc8pDnXVdXrvJfXv0vbPTuARBGHRoNDWCEC7l6DsBIARhboc/5RgOJwBflwFXdOt08Tdtrp54OgGJgOII4DggSBgYyXMjreRyVYzMQ0oqbSrMYewQL6oGx0ljhdPM0z28+z5aMaMaBWm1wFpc1AihZ22iXLTfgVCuAOKDtROwOJwFSIQQPLT+UAhjjeMwoHtHxOvb9793h9vIy55cbCHeJpV6fe1MZGOtsdh5HCAVgLDvrbPQWE6i938tzCjGqpQkBBQ+MWtGUlpVZJ1vBzfZZl/WQ/cxWacM7qE6BqOuFAPn0ipRBMHcTz9ka5VlXFzUDwwZGFWNUy4AOUJ/fbCZtAJDJeKnrZwL561m6Mp+u+FdLFlw3a+KqzFunyTxsjKHimD1HlKehFDwGwgoPkenH0b4O5c/cdBPPcglJ7JTH1ZrSCRGrczPVKyO5HqPI7rcCeQ8HmxRGbwv7Y2D4CVNhFMWl7IAcEGsxzsx5hlSAfMVnexbjUc/NmDxlUojc+atiH7kmA0N5cZS9wya8O2q8I00GRt13kyMy4CKTCdb61dI6263w7TqCmotwRUr5n4D1wo+/H/jV5PtfBf6reRzrOOoHfuAH+K3f+i0++9nP8l3f9V3HPZzS+vAj38fP3ttgO1QeGLgBTXFwD4KZK5GQ7NGi2/KRblAaozpzDRQD4+aowamWD16TgDE7Jft+bPUxvrH5DTYT5oaMOjQSBoa7oI3c1ZWrjOIRX9p5EYAwPEUzBTAWc/UcgLG67n0Clpo+uAE+UWr0tt8SQnCle2USwBCCWAY5dope/fiTXg8tK8rzC5svsE2sGBgJGNAQiyvHeNPpN/HV9a9yR8S0o4BO4IGrQJfFve/7IGM2Q8XAwGvQdMoB24dXHual7ZcAxb4A7AyM4Q6EA14Ll7iw3EQ0unScIfd2C+kiUkJ/g3vxEmudACfosOQM2ZgGdJzUoZfytshAhLLGKSchscg9vCTqMjZX7a3xivU8MBRooL6vswII2erydmqiWELhn2IQWp2iQX77uUtIDADjEKjPbtLwhpEsNSw15QTa96SsGfEckTY2URzXTiGp62cCWTO2NwytTRzkTSNLP59jxE5WeAYUIzDrsiT0eShb6YdJcCSsKU8p7iOWGTAxreE2TTzLtstf83JJhH5WR5Gd9aENI8MotkrK1GfIv4ugPHLV9DqRUs4EBiimgvLAKDfxzOKlRxZgd5oHRl0JiTL/rTVkPEeki7x29lsePC5lu8wIOIIha6vBOpsl0tk8Tlx4Dx9U9nF+uXmg359HHabzxnkp5WsAyddz0zYSQvyEEOJzQojP3blz5xCHs/8KgoD3ve99fOhDH8J1jycuplYlK+AbYcBSw1fU6+OgiycSkj3ZpNv0wW1YPTBmqqFiYGzHLZZbPsIN6LjRVA8MgMdOPcaLWy9yZ6x+LzbYDD5HawxYt7TPw+9vPw/AMDxFM/HA8BZ0zEB6//VospQAaMGcTGQnAIywT1+4IP0MkCJOaZx/0uvS0iW6fpdn732FLUfgRz7tRI7hi2NgZdWsN629iec2nuOa69AOm2rMjo9/xCaeM1UC2K6HPsstPwWOp0lIAB5efphXd19lGA3ph30A2p4FwNhTfxevDZc4t9xENJZYdYeTHhijPYhG3A7bnO02IejQZngiITmm8l1hyDjsEpJcYoiFqQFZ06uPMbGdo7fTTUKVB4bJSrDTo80xA+nf3UYpA8NJm+/M0M4CpjgGwDBDA16nRKFRnkeU4LRKPTBs9PhcjGpsTWYxGTLjiubejEvU57vO+dPN9u7QwsAwpAVZ6kWNhq8CuPKmAEv1PDDUsW0GglPBkRljVPVYhmmTO90DI2NgRATeJCA1LR41mNJPZNIJIx7VFkla4bei91knwcj8vFEs08a6NgMjYVcMwqj0naC8fKoZZ6aEJKySkIhp91B90EX3SLZzEhUkUTZfi2wcdgNUoRlChu8P2FlnD5+pkJtOO47YH7Bpq7VOwBvOdPiF/7pm1Pwh1LGbeEopfxn4ZYB3vetd8piHM7XiOOYP/uAP+M3f/M3jHoq99ER67HO1qWJUGyI8+ol/ysBoJmkoPm034uYcGRg7tFXEmdek4073wAB4dPVRwjjk/xsqOUZTdHGSF+Oi+kk8cfoJfMfnt3cVA2MQns6ZYi7q6rmWDu3KFstND+F6tJ2I63M4x1e6V/hP1/8TsYxxhAPjAQPHQcY+zSADd4YnDAxA/cF6Yu0JvnrvGdZdD3/QVGwGx03AgMU8T0+tPUUoQ3Zch2DcVmOOfHwWky0FpL48d0cBay0f+o3El2c6qPrw8sNIJNe2r+EKNYG1mnju3QXghV6Lh5abMO6w7NyZlJD0FQny5qjF+TONBMAYnKSQHFMVowtLzTk909vCIjswGou0sZkySRdC5MGTsDqFJGNJJD+rWJ1rTDAwqg37wgoauD6uuYoK9Uwo65SesGv/gUNjYOim0iJXMFkyVR4luVjGSJbG8Ra3jWcAMLwUkApLkw1yY05X/KslC3WTGMyEnTor/nUYGNPkEDawaPr41Fj646hU6tPwjRjVMKYxNR41k3aJZDw2BsY4jNNG1mbsm08hKT/HmalvFVvDYNrUBDSLx1EMDAvoYoylTgpJZXJKep1JvkrqKoXyDAzL+SukkNje06EB2la97/R4oZ4vTzvwePz8Eu9741ROQOn4zfeeeez9luMIPv3T7z3QPg5ah8nAuCWEuAiQfL19iMc6tHrmmWd49NFH+cAHPsBjjz123MOxV8J86CXAQbYCfjweGBkDI6DtxAeWEgCpB8aObHOqrejabTea6oEB8MTqEwD8VrROO4a2vwyu8kzwCRdyxb7hNnhy7Uk24iG+lMTj0zQTAGORY1T1dd+hlTCAAlpudGATT1CSiFE8ytIbxj2GQuDg43rqerrEqVP0SSkg7NnN57jhe3ijjuEnsbhgwLsvvjv9vtVbTcbsLTYDI3knbcTJO8kNaIhyxtnDKw8DiVnpSIEfy43l8v3vqT+dr4Vdzi83IOjSdQaTEpKeAjBeGTY511UARkMOThgYx1RmPKrV4d7Jmh/biqSe2JorkuWr2k5OQlJG04aCiWe6Amj9aBnNPVSNShkdOZdwUkNC4jiTVOc6MaB1SvcFJlhzGH5JJgOjrIlLV5cToMMGMOXBgKoYVZEzrIR6jUoqIRnZGBhaWmDcfyU3iunbUWXeOn31vA4DQ21TttIPU9IpaoIj047TG0UEJVKfwHUYRTFxLJWvQ4W3RZnRp3m83HaWdIy8pMfGesh70dhAR1DnbFYZl+8qw9NhGJUCS0Vgt+x+0+crjLLYWRtAA5nfiopfrsnAMDwwbPe++Qxax+LmfXxsjJ9J/5d6z+tv//ffzs9895sqt9PlCJN5lvzsPvCKO0wA418DH0m+/wjwrw7xWIdWTz75JC+88AJ/9+/+3eMeSnWNNYW/oRxiHbVyeWwSEg2keAEtN5yPB0ay2rmNAWBY9OaPnHqEteYaPWIuRK5y8E3iWl1i+qPFbHi/9dK3AnB1HAMuLe2BscheAMm12ZXtVELSdOIDx6iCuo4Az28qWQ3hgJ4Q+KKZXk+PiFG0oOfmGOqd597JOFar7/5oWZl4uj7eAgMYS8ESH3/qr/Lndvdo7l6go8e8oGwpIAUwtmU79cAIGJd7YCw/jEAk5sIqHWm1uVq+/10FYNyRK0p32liiwxQTz77a17Vek3PdJgRL+HLEdq+fJjuc1NGVCWCMw3LvgsDL9Okjy3Z6Qq8NIs2fFcvUmVd5YORMPGW1zEP/jp58Wz0IpphyVqWQFAGMeTEwinKCKnr3fkv7AKjV5XKACTIGRlmDCnlj0zCWdg8MwaSJZw0AKJWQDCwpJG5+zGBnYMSFhrk0RrWwel4F0mTHUOMpS8ABxUYSAkNWsz8PDFAMjLLrpEGUUaTMPqeBAyYwkRmCTo5FCKF8cbQMyRUWfxQnFzNqZ2BkgKY6drnsCxKgagYWT3qcWJaeg3TMCdhjA+/0+RpFcaXxaNHfZrYY1Wy78v07OYaQ+r2SbUXRA8MOHkPGCotrMDD2U+Z7NWO2zf0wR15zATCEEL8O/D7wRiHEdSHEjwM/D3ynEOIbwHcm/z6pw6xEutGTmoHh4x+jhKRHUwEpbkDTieZm4ikR7NFkpRUowzwRlnpgCCF475X3AvDoqJGuQoNiYCzqqu4Pv+mH+W7vDH99W/0h8HwjRnVBx6wBDMXASCRMznwYQI+eehSA5zafS461y54j8J02OGoC4y4yO+UY6j2X3pN+3+hfSEw8PTwW18QT4MNXPsDfvnOPPu30efUIF/faagCDjjIWdhv4shzAaPttHlp+iGfuPcNGEu+82rADGBLBOt0UmGjFfdaLMaqJhOSeXFJMjcQY1I8G82G/ndRMlaNKV2i9x1Gcas6n6eLBpHbHlTTmvM68wgNDTNL96zjU689TlkCixxzFUpkBVsQPFscybw+MTEKi93/4DIzKRI/EA8MGSpirv1XsBNeZBIxqMTC8rGm1rfbrbeo0wWFy3fU4yrdVX02z19lMPCvAtgKINiujR4MMg3FUKvXR52wYxqUMjMCQkGgA0sbQGSf7sgF+fgJUVgGafoH14JRIYSAvu4lSpk29c+YZiS1VJp5a9lL2jGTnKzaieMtBAzVm9e+4JosH8uk4tnu0yMAoAwZzkryq2GPNCssxhA4BwDAlJHN+rx5nzcUDQ0r5l0r+1wfmsf+Tqlk55kNi4snBYyxnrsEWI7dDjJMAKQ1aIprLSjzDbcbeEhInoWs3aIlhaQoJwN94+9/g9Jf/JY/vrnF9xQNXTea9BdbVLwfL/IJ3mduj9ZRGD4s9ZoY7RMJjiG+k4MzHxHMpWOJC50IKYIxGO4wFLDvt7NyI+MQDw6iW1+IfvO2nuPPv/yf+0fgMbS3HWGDgDjAA0IbSYy866DLBwAjwGbE7DJFSTl09e+rMU3z25md529m3AXCqcap8/3u3GQWrhAOPc8sNaCzRiHvsDJUfTroCnkhItuSSMvEcqGhW5YMx2pd7+UntvzRtWzv52yQkYUK7hvIJvV9oIG1NiGqAMvDEmkJirJbP4jvhu4L+uDyBBPLNUNaEVEggCikk85poO1OanMOYw+vV7lr6fp1WUnF9IqP5rGKwpM3TTCkk2T7LJBk5CUltY04qgSvdQKbMEVmv+dTPiY0BBFpWU29F3Da+/igqvXcbyRiGYcQwjKY+E6aERF/PMrDS9xR7S1L+PgAtITEBzWoPh6r3gSnHSAHNmpmbniMYjNXnq4okrZLHTJOQlH2+ibjcWNZmbpn3QxlApQE5yBhFZfeRVzAutqaQFCROsTycd5IjMKKy58tsO846TAnJSR11DRMPDJnFqLrHQb3ubzL0lgASKYFPw5lTCslgm4GrJuaart0QYakHBsCZ1hn+u90xTthKoyQhkWMsalMEMNyhJ9oJ9V81HwttZjjYZuQtASKL7JwTAwMUC+O5DQVg7CZsj6bbMSRBUeoUflKq/lT7Ab57r8eubBXkGAsM9BgpRu0kRtWVCwy6JADGFp0khaSBF4+JYlnKGnny9JPc7t3mmXvPsOQv2U08d2+z658GkuiyoIsrx/iEeRlJfxOATRIGRqDewR1x4oNxHKUn28Mwtq786gZF/30sjwrMJvTjOC5NgAA1iR7nnP4rWA8F2Uat5IqkSbOtgGsadyQznb6VgeEwISGZl9HmpAfG4ax2pg2ajYFhGCVWNZSek78+VTGqKRBQ43zrMhvDUgZGQfZi/mzaOCDfBJc21yIDRvS464y5E6i/+7YUEjXG/DnZrwdGfxyVXic9hpGFgaE//6hGLKjnOIyicj+NbJ9KahJW+IyYnjij0C5ZyjEwZvTA8FwnZVqXe2AodpgGAqpYSmNDQlJp4mk06bUZGLXu/UlpW53I1crZRrEPAAAgAElEQVQUkoLE6bDeSbkY1fuIgXECYNxPlfpDdDIJyXFM/Aeb9JwuLd9VD7nXoDEvBsZgi77ToRMY+2ZcmkKS1miXnbjx+mEzAAy32RPtHOgSLDLoMtxh6HRwBKnfQkPMSTqEAjBe3HqRMA7ZG6tV+qbXMa7nCQNjopLUnl1aCgxw/MUHehIGRp+GAgQcHzdhjSykl8NgixiHPZqJL0+AK5WkrUxG8tazbwXgt1/+ba50r9gz2XdvseWs0g5c9S5oJMAE/byRZ3+dsddhjMe5ZRWjCtBiyEbvJInkqEtPcAepw72dWaHfk9UmimrF1daE+G4mX6lKIcmxHmaY3DZqrIBPY2DM6oExzxhVR5gSkvqrtLOUm9D1bQwMz1iNtyXUQN4QM6xocHL0dVkfAApyDIySxnOKiadtxR+S614BpExbPa8j82gHGkCzMzAmPAlmlJBkHhjljb9+FoZhuQdGjlFgMfEECBJZmU16BsqHQQFK9uvhOYVEpIrUG9BMm4Q9MwObQS9YlcaoOonspQKUSGNnI5O9VSUhyWQedd8bOQ+MErNj00NEfy3bvZJxZebNVUCKUwAXDgNYEEJJSKTMonEPI4HpqOsEwLifarCFRLCrJSSOjyfHR59C0t9kVyypyTyoNBTmZ+K5R4dTbRWdidfAZ0x/HKWrAlNrtMdWlAAY7usEwBhssy1byaquOpctd3GNRxlu03cU4CKESFJwwrkxgB5bfYxRPOLl7ZfZCZVh7ZLXKXhgLPD1PI7SoKZss9xSMaquXGAQDHISkuUEiHVlhJQsJkA12GLkdQGhWGFuAzceAbIUwHjLmbekspHHVivSrXZvcZdTin0BGbOCAfdMH4zeOj13BYCzSw0I2ul2G0XDz5M69NJNqvYfsUUhqu0SAKOsCTHSASp9E4oeGNaGZQrrYYZVe9sKuNkMRRXu/ZA3rNRjmqdbfm7/h8zAqJNCouVAVSviaXMfVZsCmiaeQtQ7f2ZjWDYWx1EAkBmvWcYCmgW4mkxiqMnASCRxdSQk5jmZ9Zrr+3UwqmZgDMcx/XFEK7BLSKoADN9zUhmS7fnSKSQpI8YCmKUARiitgJm+TiYDYxYTT13lKSdOLgq6CrDNx6iWgWBasqTfHbOMudoDw/ShGcfSaqyqQET1fZ37TXm0qO/jGaQvs1RmcpoBhfcBfnECYNxXNdhimPhDaAmJQ5RSWI9yHFsmyJA0snORkPTW2RJLqlEA8Jr4Uk3OSwGS8QDiMZtRwFLDNUw8FzjZAGC4zWbcShNlAJquZLCA0a8ADHfYo21cd5WCMy8DwTefeTMAX7rzJTajPgBL/nKeUbOo5+a4KjVWbSeGuorNYBqxLVylnhKJJMPxcKR6thcSoBpsMXCXcJ1EOuU1EEg8ytlHruPy4Td9GFe4fPDqB8v3LSXs3uFWtMzZrjLyTRkYYsAdk4Gxd5st9xRrnUBNChOgo/06kpAIIU4LIf69EOIbydcJd1MhxNNCiN8XQnxFCPElIcQPHsdYq0pPtvsjOwNDNx11ovxAARJVxpy+6zAKlf9GpeZ9SlJIndW5hle9Ap5OnJPEAfNzlG1vJglUbT9rHdQPoU6lKSSW827KMWxMDVCgRJ5BUGGaOmMcKeSvoS2W1HOVNKnqWuYZGBUJGROr5/UiMDsNN/e1rPJRvvtPIemNQ/ySFXr9zI6imP5oeoSob0giqjwdVIJRtYTEM9JKzHFMbOfkU0hs+8zMgqu9TqaNW1epiacjKpNY9DiEyJ6R4v6L+4T9MTDMz1bK8DBMUMMKHxqvwMCoGofj5NNTDuOdpHcZy9lBqUWuEwCjRv3SL/0STz/9NE8//TRXr17lfe9733EPaXoNthg4SwSuo16grp9SmY904j/YZCNus5pjYIzZG4UHp4D37nFPLhvsjkYKYJT6YCQN0b2ozVIjYzOohndBmziAwTYbUStZOXcAQcOJGSwq6DLcZodW/rqL+ZnIPrz8MN2gyxdvf5F7yTU/1VjLxeIubFLFcdVgm1h4DAgyOcYigwFgpHpkoIsGMBaSOTLYYs/psNLyU+YRQIDdm+evvfWv8bsf+t00MnlqDbch7HM97BoMjC4AS/TzDIydW9yVJlNDSUiWxPD1xMD4OPA7UsrHgN9J/l2sHvAjUsqngD8H/B9CCIsL6vGUngxrAKOs8dSMC83WKTP2M1dGx1Gcoz5PHlvk/AdsHhg5E88ZWA96lbmOiWeYrOaqpqTCj6MApsxzRVJJSNT3sawftThL6c88sEgOsmZWMqpgyHiukRIT2RtwR+RNUOueu5bRcFexQaKo/up5zvCzVEKSXz2vy5LQ8amnOw3rdvqcxLGcaWVeV+qBMSoHmvQzMBwrFmhrKoCRSSLqGFhqrwyrB0YCTIyqJCSuSFffKz1XDKbX4TAwRG4BpWw7IQR+4gWSSWTK2UF6zABxXP+9YV6DUt8Og4FRGY3qZPK9Oqk3rsibKB/GO0kYIOH95IHxurIl/4XP/ALPrj87130+cfoJ/uY3/U3rNh/72Mf42Mc+xng85v3vfz8/9VM/NdcxzK0GW/ScJcW+AAVgxArA6I2ilHJ36NXfZJ0Wq6nMI8CTIVKqBqQd7HMcUkLvHne8jsHAaKQgTTmAoczttmWbx1peCtsdi8Fp3YrGEPZZl43ss7o+TSdezCYOYLDNVnyGFYOB4cmw1kpCnXKEw1vPvpUv3fkjHkom+WeaZ14/nibHUcNthm4HIQTdxP/Fkeoc9ceRkpotWg22GDktQrwEvPOTMZebYh5rDbbYJf9OAggoj1IFNak41azouzdfAeBr/VOcKzAwTvujvAfG7i1uRle4sJIHMNaC8PXkgfH9wHuT738V+F0g9wdaSvl14/tXhRC3gbPA5tEMsV7pSW6vQhqSSkgqPDC02ZxKrqgy8cxTyysZGAUJSZ1VQO1BYFuxdw3Qpf5qpPo+WcSc60S7CJAchg489UwYlcduCiESsz9lUGgDDVzHyY+5ygR1H3IJ8xq2p8gfdGkvhbCCgWE2lFXAlWloCvVXz/U9W8fEM4rjdPtZV7i9NIUkrDbxjBIJiRXAyLwtys6JjlauNNzUEpIEEGmUgp/1JUs5A9YZY1RNULUcDFD387CCVaH+n0hiVCvYGlM8MOqzj7LjT7tukLGqZGJGXBV7rN+76p1nvz+LyUGHYuKZ7FP7YOjjvt7rhIExQ/3kT/4k73//+/ne7/3e4x7K9BpssSs6BoARIJA4xEfXqEdjGO9xJ2yx2slW4j3UBPpAMpLBFsRjXh13WFvKPDCU3hx2BiWT9HRFN5G1JA1vy13gaMbhDgB3w6ZahQZwFhzA6G9yN+pwygBcfJKV8zndf287+zae23qBrwYBXuSy3DQ9MBb43BxXDbbpOx26DU9NKt1MjjFcRDAAoL/JwF2i6TtqZctI4FlIwLF3jw2WDaAxY2Ac2Pdn8xoAL4RrXCh4YFxoGikk0Rh697g2Xs4ADF8BGGf8MeuvEwkJcF5K+RpA8vWcbWMhxDcBAfB8yf//CSHE54QQn7tz587cB2srPTHvVZp4JtsNK7wycgwMu45dUdDjNEq1KjZxgvVQC8BIPAgsDAx9WC0lqGVoF2eTeZi/hMRc6T9MBkZ/HFWyGXQKSZl5IIAr8vKKymtp0NFrAxgGCGBb6PLTBIl6lP4wVok5tnHsl4HxlksrE2OfVur+Nv1dZmt7NHBou56B6YExmu6B4SYeIikwUZUuUnc783qU3Eca7NTpH1WpN6DOVyxnO2fmdrYYVcjmhNbPZ3iB6H9PP27RR6W+d44JtJQBGLlY4IoEqGIKiY0pB1M8Wg4BWNBDiKRMGVr3A4DxumJgVDElDrM+9alP8fLLL/PJT37y2MZQWYMttlnOrYAD+BxhEkkS5Xdr1MwYGG6AJzWAEWZa7lmrdw+AG8M2Dy4l+/AaOJGanJeudiZj2pIdVto+uOpl0fbk4gIYCeiyI9tcSRsjj4azoCyDaAzDLW6Rlw5pucLeKFTn/oD17Ze/nb//R3+ff7vUYbnfZaUVpDCsJ6LFXKE/zhpu0xOd7Nw7Pk68wHIMgMEme07XAO40w2ZBo1T37nArfiNnUlBVAQiBGLMzJwDjujzLldNJ1GrCrDjXGPNZzcDYuwNIro26BtChtlv1R2wuEIAhhPh/gQtT/tcnZtzPReAfAh+RUk598KWUvwz8MsC73vWuI42wqSshSVNIRhUMjIKpXZUHRm8UZlr7Cs37fjwwtPeALUa1yMCoAiPyHg6J2/88AQyRl8vU8VqYtVLPhFFoBSbUSm0dE8+MgRFGFWBA4fPVBTBMJoCNgeEmoEuVN4K+7nEsiSJpbeKKq+d1vTt+4O2X8F2HP/vUeet22mNgv54qZvNaBhqmEpIwZhDGpeyDVBpSCUwIxqECt5aa5W1aXaaVCSgpzxUbi6e+/KdY5rugjJml34P9cWgdszpuQUJS8rzqZjz/bM8OYDQD+7tXs1KqfHyy57WGiafxzjssWVt6fnIeGHM/zJHX6wrAOK76/Oc/z9/5O3+H3/u938M5hD94c6vBFhvRBdY6yUTayQCMefkQVFZ/A4ANucSDBoChpSw2SnVlJQDGOsu8U4MgbgMnHiGIKz0wtmmrVVJHPcAtJ+buIjZEYJgvtrKVXcen4cT0F7FJ760D8Nq4w2nzuicMjHndf286/SautM7xSv82rcEZ5YWSXM+GIxc7HvQ4arDNLq0MDHB9BDHiKFlZs9Zgiz3Ryd33oGJyFw68C0cw2ORVZykDZhMJSYPxXBgYodtinS6XV1WqCA3lgXHGH3NXe2Ds3gLgjlzhaQ1geA0QLqvemPW9xZGQSCm/o+z/CSFuCSEuSilfSwCK2yXbLQP/BvifpZR/cEhDPVDp5i4156wpIalKrkg9MKqo5aa5X0XDMhG9WccDI5n4VzVYkEUy2lYuoZiikYxvjiuFRZPLpn88HhiQJcVUmng6RQZGzWu5T0PAjkXiq80lU2POkvlw0QOjKvoV1L03i0+FEILvfdsDldt5Cf0/qohzrRofWCI/Pd2UR4zCuHQlP3CdNEa1ikG1G4Y1JCQJU6NC6mHKdCo9MHIpJEmMas1zZoJf5SBOAtgOqxkYgSuSmNhqw081ZvXvKqDPrGYN/5diqk6VhMQE42wSO9AxqqTbH46JZyIhiQ2fo/uAgbHA3fji1Cc/+UnW19d53/vex9NPP81HP/rR4x7S9Opvsh41cswHSBgYR9Ws7Kn55l1WCivxmRfHvisBMO7JZRUTCIbePCxf7Uw9MBJ5Q7Ki23QXVFMPMDDTI5IJhePhiwU18UyuzYbsGtfdn891N0oIwd965Af5jr0e7fWnE0BKS4IWmFFzXDXczhJIIJXbLCQYoGuwyRZJAgkYprtH+B6rW8l9f33Y4Yx+JyXv3YYI2bWYeNaq9efZbl4CBJdXNQNDe2AMMw+MXfXevSNPZRISISDo0HUXi4FRUf8a+Ejy/UeAf1XcQAgRAP8C+DUp5W8e4dhmqqAATJRGJibb7eoJfYmOvZgOYJ9EO+nqvnmMaeUIkWqj47h+k6cn6enfYsuYTS8EWxUb8LpjqVvFZuFQIguNc12t75eVqRCe49SWhRQ9Pvbz+dqWVA9lKBobpopVDaXyL6i6/yBhaxyGbEiofYc1YnynlQnSlDGZNGCh37OtkpV8T3tbVFzzoLaEJAMqbZ4a+p7U8p9aKSQ1vE6KZYIBSyVSJNMjBipMY5PzEEYxQpS/C0yJBMwWo2qyRmzRqJB5iJQxQfS2JuBY7YGR9605jHdSXkJyYuL5J6p+5Vd+5biHUF3hEEY7vBYZ/hCphCQ6Oup1MpG+K1dyJp5a5nGgFck9pWHeoMuZKaud5R4YCYChIz5ddS4W2k+idxdQgIDZyDXkgkaF9hUDY51ulhDj+LiJXGEuEbpJvTM4zTtv3+UD44ucagXgJCuXbszOogJSx1W9de7F56ewGRZUjgEqhjk+kwPuQJm0LtyYk3fSXbnM4wVQdSWQB2OcAdx6hhvBG+k2vLxJqONx2htxd3eoJlTbN9TmcpWH1zrZ7wcdlp0h66+fFJKfB/6pEOLHgWvAXwQQQrwL+JiU8qPAh4BvA9aEED+a/N6PSin/6BjGW1peQRpSHqOaSQ7AomPX0Zs1GBiBJ1Kpie3YUIi8nEFCUsWmmNh3hZQANAOD9HfMfcyjcs3CIRnmmc1eJTBRi4FRP8KxqKefNwPDdUQutrPsHig2wbbznK1u79+nwlZagrPf+ymXrFHyeTXooxlxZQyM1NuiQjbkuw7jUBldVt1DWRSvhdFhgJ/VkqUMfJr1nJkG/WVeKllstB3YhQzkGyW+HWUAgxAi92zPEqNadq3MSt9jkaxMFsl7YNSUze3DeHeWSuOspZwpaWrR64SBcb/Unmp4b8Vdg4FhSkiOHsBIKdVugEgkJHsHkRJsv4pEcEuuTjAwWo5ltXOwxdhpMMJXTVHSxDUX2cQzuZ73ZJfTqSTII3AWlPpvMDBOGQwgJ03BmaOEKZEpbcmlREKSaLFduZjgznGVlNC7y+2oq9I8IAdqLuy939/iXtTK4vEWecwGgFFkYJzy44MBGIMt2LrG17nCpdVWNnkTAoIlTnsjYgmvbvZh8xqR8Fh3T/PAqWa2j6BDRwwZhgccyxGVlPKelPIDUsrHkq/ryc8/l4AXSCn/HymlL6V82vhvocALMNML7CuNGVPDvl0Wb6iN+OwMDNXY1DPxhIzCD/Umtx98s7IxefTcUuW+daSrW7H67QjDzDGVs1QOpXblm4XDoVGbEqBKmU9q4mlvKOuCEsVEmf00KacsXlV+cl9l8bwVAEZU7X3iGA3zfn0qbKUBoP3u23zOyq5nO2mCNSPO5oGRpbLZmS4a6LCZlHoGi6fK5wYS+VlYbQQL1PI6KZYpISljYGgwpcrcWP+/1POn4rppqRCoBKP9SEjK9529I8eRnVXhOo4BpNRIXsqlkBwOsCAMltP9JCE5YWDcL7WXAQdv7xQkJOJoJSSxcNlgifNai+02EDLCIT4YA2P7Br3gNOOBZ+jN1THWGrLcA2PvHj13hW7DS9DfBMBwFhjA0IAAXaMx8vGjBVyFBgPAWOJ8V193H5EkxMwVQEsAjE0Sc0qhVoOazomEJFfDHYhG3AgNeUPCZnBZUMPT8QCGW1yPljjTzXv5KJPWBbu+CYCxzrJh4qnO9XIQs7UfCUk4gte+mD5TfzC8ypUL7fw2jS4rnnq2rq33eGjzGve8c1zqLOVXRYMO3eQZvLnV59Fz3dnHc1L7Km3guFtTQlIlNdGTaO1B4FnSIszGxhzLtMoo/LOxEr7t8bN85hMf4Fy3WbpNaoAYJ/4NFSvrJsCQgilznGibzUIcy0MxsjOvX3WChGqIbCvijshWdMcVIJDjiNQHIJrByNCsB0+3S/+fvj5pKkTJWDxjxbcq8jfdr9y/T4WtPEcUzAtnTCExxlLWyHuuQ8Nz0lSoaSkkoO6HOtKQwDT7tDX4TpYKUwUEgGEAXAGKAAXWSr1zZoIBpSkkBXPjOmksVWOGzKwVEgZGzffGco0o+bwZsZ3toqOG1fbVyUuuoyR8kLyTDgFXyBgYh+MtdFz1umBg6NzaRa2FGF+6Yr/Maud4JSQ9bxXXcTMzUYMJsnsQKcHWDTa9s6y0/OxF6apm4VQjLpeQ7N1myzmVnZekiWsssoRk7y4Dt4t0/CyW1PEXcxUa0vtvgy7nlk3mzXxNPAHobzB0O8TCYynwctdzIZvy46pEhnQ37k4AGAspx4AUELgVL3NmgoGxgLKXresA3JSrmawteSd1vXh/jLPf/d/h//4O+PUfRPod/s3mgzx+vrDKHSyxJAaAAjDYvMYNeZaHz3Ty2/kd2sl2NzYHs4/lpPZdmoGRxaNWABgVlGo98Y9iRam2TvydenGXYESdJhF7szSPNvACstVE5d5fTet2nHwMKJQbRe6nHIe0WTgsCYnZcFZR9UdhRFQRjapMAdV1jCpAIDfXxM3GwPjR9zwMkDE+p5Tp2+G7opZnQK30GaGAl/36VNjqoAwM8/6zrdZ3Gl7KwCiXkAhGoQImyuQoart6QEfK4gntIJgJSgwPMYXEZGCU3Rt6X3sVsdH6/4Wxjo2uAMES/xcp6xvBAnnGYknlTGkrUkgcUfTAqGadHbaERO/SBPIWOY+ibi38R2g2m9y7d28xQIIpJaXk3r17NJvVD8GhljZxY4XTnbze/aglJFvuKue6jeyPp2G02TsQA+NVbrGWmdkZ+z7lW/Tmu7e5ywrndIMhBAhXARiLKMcA6N1lx13hdCfIzqPj4os45wK+MLV9gz1vldgJcikkGfNmjue5t07P6bLS8tW5SZpy31ngaNDjqL3E9Nb0jFlkOQakTLI7csVgYBigy2jB7vut6/T9U/RpculU8l7y1Li7niUZyVYv/V767fpbP0ov9nmsyJxoLNGMe/iu4Np6D7nxMt8YnuZNFwvbBR2asg8kUpOTOrIqemBUpYukDIwKJ3y9ImldmfW0dryeiSdkqQPzXJkruvdXmniKvFwC5jvRNk0u4xoGe/upugwMz3WyhBob/d/NGrOqBqf4+WZp1v+X732SF/637y5tPPWYdQqODVjKJ1nYPQMgWz1Pr/k8k2cSb4RZEzXS3ze2t0UGtwO30gOj4bkMQ7VwZkun8L168iKToVAlQwLSd4JVlnKAFBIb+JXuv/C+s4FCnuukgI/tfQeafTS714kec66vKJTpgRHGVfd+3tOi6hk0QdvDAlWF8Y7XAOf9wMBYeAnJ5cuXuX79Onfu3DnuoZRWs9nk8uXLxzuIZOXynlzhwkryIOZSSI5I/7x1nVuscW7ZAHSScXS8iN39jkNK2L7BtfgNXL44CWCsBDHPl0pI7nArejJjBgC4PoGzoDR6gL27bIkV1trGHwTXx0NNeAZhzNIiBTlvv8qGd4azJnDlJsDCvGN8+xvsOEusNnWDm3lgnMSoGpUwMNblMmcK0cquWFAGxq72lFhhrcDAaLly8ca89Qr3vPOcWQomWGFdP2Kvt4/7/s7X4U99FN77M/z+8yP4z1/gsSkMDDHc4ZGzSzx3/TZi7zbX4m/nLZdWCtt18MM+jjgBMI669IS7qkn1a25nrqJWmfapFBIzLaJa866avPnS94spJFWrqMoDQ32fTrTn7IdgMhQOg67dMLwNbJ+34TkpwGldEU9AiTqr4aaJZzhjooEQgqrNXUek95VtzLq/U6aR1UCRNto8DA+Mg+7b3L5p8a3oBB4vr++p7UokJE3fYTBWiwepDHpK+a7aLoplaSqRHltm6mt/H0D27rCBAQdhYFxcqcNmUMferYiNBvUO7Y3CSiBHjzuWcqYoaFD3/b/4b97DJQuAod+9iklmZ7+5rmm6W33vF0FbvyJ2dT+lwQopua9MPBcewPB9n6tXrx73MBa/dm8xdpoMRJPzhdXWJe+IJv5SwubLvMz7OJ8DCxJTuyCj085ce3dguM1X4rNcXjU0mpqBEcTTTTzjGPbucCPu5uPeHJ+GWGAPjL273JWn8n/kHB8P9Rn7o6jUJOlYavs1brOWsVwgve4tJ5ovA2jvNvfkJKMmOJGQ5Mv0Z+jmJSSBiBYzjnf3FqAAjKLspeMtoMfJ5iu8xhku5d5JCWDr7MM4MxzCcAu6F6Fzhm/c+jqOgEfOFgCMzhnYeJG3P3iKF770nwF4Tl7iw1dO5bcLlhDjHheWm9w4ATCOtLTkozJG1ctP6KuMEXUKRGW8YpR5FdRpWKLEoX6e81rXWPkb15WQFBgY843UzACM/ZpcVlVdBkbDc7ibSA6qVs/N+EObn4Rb8PiYpxQD1H01GFfHgOomVbEq7M01ZDT6Q0mecbIUnP3sO8/AKAcT2g03nX+UAR1N32VvGDIMY+u+fNdhrwY7x3OdNFnEClK6+t1RnXpzkBQSz3Vo+S7f89aLlfvfHYbKj7oiajiMJaMwqmRgaKBvP/fQ2x9cte/bNEGNJe2qZ9CQfNXxwMi9kw4jRjUnEzwx8TypRavNa9zzL3DOa2Z/4DSA4cv0ZXio1d+A0S5fjVfzRlBJI7vsR/s38bz7dQCeDS/wARMpTfXmETvDKR4Yg02IQ14dd/OsEMfFX2QTz+1XeSV6Q9bEQcLA6AEs3ri3b3A9+ubMuBWy6x7I+QIYOzd5NXoyfyzHIxDxSQqJWUZqT2YEm4ABrmQQLiDYo82IMVKMDABjoSRfcQxbr/ASj+fpp8k7qeNF5clIZdVXkc+0FBDxjds7PHi6PTnZXToPu7d550OnGX7uJQggXHuciyuFVaSgDaNdPvzuh/LPy0kdeumJq373lXtgZJRqR5Q3qOkqalRt2ue5ygNDAxg2unpm4qnp/vNbAcxWLjUDo4aEROYBjPnKCQyJhZSHQqPOp5CU77/pu5WgFSSgjmHIWsXAyOnv5/z5VNJDRFjVMBdW8SulQwX6/zyBF89x6EfRvvdtPjs2CYkZP9ttTm+tGp7DvV0172xWAJC6KmNG4ziNGS3dTkcwR9XgZzECF2bzofnq3/pz1v9vSkgaXnk0qtpWSUiGYWx9h0HGrkoBjEOQwoWJrMaaBFR8BivuNyEy4934kCQk6TveiFE9jOMcdZ0AGPdLbV7jpjjHhWkNpC9nn0jvpzZeAuClcI1vWzPM5JIVyZUAdg4IYDwfP8CP5fatGRiSzd4UAGP7BqBM9p7oFiQkCY1eSml9iR55DbZguMVz4alMVw/geCkDY6EAjNEe9Nd5LlrmoTUTuFIAWtfnYOkzZkUhcvcWL0fvzrM9kojZhTovx11br7Djr+FGAavtvC9Ox18wMEDX1nV63gp4zSzVI7mP2t6CAVRb12Dc44vRBS6fmpS1dVwlmZvJmCtJ2KGlVoS+dnOHx85PSQ5ZOgfjHt/1WIct/wZD6fFnvumbJrcLOjDa479936OzfLKTmkPpJqHKnFM3r7vDsF8+7QoAACAASURBVDJ2E9SkeFixiqrjGvX70EbTNhkYs8oOqip175ezNbLAIa3Gi1SicliGeeZ1tp33huek87JKE09Zb2XZXM09jGbIcwRhKiGpt4ofRjXTZ2QmWZinN0nRxHPWfbcNYMLKwDBkI6UAhu8yCJWEpIqBoauK6SKlmg9WMRkAhmFEGNslEOm1i4x7bo6Akm+876oiTAPXSRgY1R4YnrN/BkZV5VJIKkw88x4YdVJIyIG2hwGqOqmERJ6kkJzUAtbmNV6K1vKOusnEfzmQbPVLEjrmWesvAPCSvMDDJsiQAClnmrCRxEzNXDf/mJG3xGuc5vELxoQ+iVE93VCGeRNN2cbLALwiz/GAuTrp+AQiJpYwXLSV6C0FulyPC4aljocr1ec7MlPWOnXveQCei87z4JTrvhzINPP7wLV3ByFjXo1OTWdgnEhIstq6zl1HSa5SgC5hM7QX0U8CYONl7rgXuLTaMsasAQzmawZ70Lr9LADPhJd45Jwh8XAzE08pYaM3wztPAxjNUwzGES/d6/HEhWkAxnl1jPE6H7qyQ3/5Kn/5T08BKYIOxGMVzXpSR1opAyO5Z8sm4HoSP67QVpurgJUSkpT9YQdPIC/zmHe0aLpvHf1a0TzmAIbD8MAQWTxrLA9HQtLIARjlDVrDd2vJBDSrQjfgdfwyQOvv5wxguJm5ZK0ki8T0sDqJQaQMIJivbCgz8dzfvk1DTlvDbUp6y+S9Tc9lOFbzFBubwwQwbGklGtTsjUJ8S1RyCqZWyNngYB4YdSpNIRmFVoAPdBx0dRoLZHHDhwFgFN+9Veyj1AOjpnGxCdoexjspM2o2PTDmfpgjr/vgI5wUg20YbPK1wSoPmQ2kowEM2C6LGJ1n3fxjIuHxgrxYWIlXE/rTTdKc7Jnr2h/ycuspOo2AB0yjoGS1czVZjL+9U4gK3FQAxnV5pjAmj4ajJg9Hcm5mqSSa8VW5lvf7cH3cxMRzZm39Yda9bwDwgnyAh81z7GgGhpwfA2PnNQBuytMFfxCV0HLCwDBq6zo3ZAEESyQkS/NkxcyzNl/mmjw3cd+Duo9Ko5KPo25/BVDeE280WRKeNvFUYNqdnWH9fQ4yCclzt3eJYskbpwEYnbPq685Nune/wKnHvmX6RClIgJXRbv0xnNRcyi82DSWT3roNr2nEN46qYhM1+0MzMMr3qyfMcZy44M+VgZGXkFSmUQgmJCTzNhU1Y1rn2ZjpMhutjsWnKi81qU41yDwc7GBHLJOVVjl/Pb2n43krGECmZ0BY47q7KUizv6QQ+76dpBmfRwqJ3QMDoBO4pTKs1MQztDMwgpoMDA0i9YaR9XrofWjTWNu7QwhhSHrmfz0yCYn9HEDCJAurPVf0GON4dhPPOuWk93NceT8XPS2q3jFCzLb9fkpf7ljKFMC9HzwwTgCM+6HuJg1kdD5v9qZXAn3J9lEwMG59mTvNqzSCRl76kAIYMs3JrlWvfRF+/+/D5jW4/Qyfk0/w2PmlvNxDAxiBmqjd2i7sf/MaI6fNjrOcd0h2PAKhHuR9RR0eZm28CMB1eXaCgaFTSBaqkbv7DSSCFyeYN6rxXAnmeP9tvQLAa/I0V0yfFcfDdxS1Wr+g/0RXHMHmKzw/Wi3cQwkYECzgfZ+M+bnR6QnpFCgp0vYijfnl32e99TDbdPIpIY4HCLqeelZnAjCGCdDQWOZrN3cAeOLC8uR2px5SX7/+W0pyduXd0/eXSFHordcfw0nNpTRtfm8U4jmidGVNCJGuxrZL0gsgWwUchnFlokcxmtUuIVFfo2RyO0+6uJmcMq6gXsPkaqT+2bxKmXiS7v8wJvGm5MB2Pc0VeNv10SvLugG3Nk+p1p1agNGs5bmiFgMolSEk0pc6RoY5D4y5AhgHY2CY1WnYU0gAuk2/dJum77IzCJHSDoaY7JaW5R7SwOTeKLSCEvr+qpP8ARmL4LBSYQB2B9UMDOXxIRmO7dGvoMHJwwE+UwZGpCUk9ns/z8Col54C6nk5DAaGGaN6GADPcdUJgHE/1K0vA/BV+SCP5qjMmYnnVv+QJ/5xDDc+z1fkwzz1wEr+IUwAjNWGYHsQpsZilfUbfxn+3c/A//lOQPKpzbfxdNFl31dN7ClPNci3tgsMjPUXuO1d4PJqO4+KO8oDAxawkbv9VfruMhvOKR7IAUE+jlRj3T7s6zlL3fxj1oMHCBrtqcDVWlOwMc2fZD917zlgikzJ8fCT67lwkqDjqI2XIBrylfFFHjo9CSodGStrltp4CeIxz47P8cjZyTEvBQvAwLj1FfjKv4TxAK79AV9y38zVM51c04IQ4DVou/sAMMLk/eU1ePbmNoHn5FlNuk5fBa8F/+UX1b8fes/0/S0/oL4mXkAndXSlm8dY2ldRIWtmWpamxnEEjiCNRLdRxjW4ka64VjTIkK2WzxswgKyRrZNCYko89M/mNx5DQnJIHhh1pARQP261qO23Gwiqr3r7Q2FgJNGodRkYdWJUix4Y87zmnuMU/DX2v+9VM9a+UGuJZ5MNcGj6DqPEhMDWkJtzVRsIpp/r3UGYMr6mbpdEsdbxXAF9z82eQlKn9JhHkT2JBbSXj2Zg2LfVz/ZhMbdAvceqImsdR6i40rgmeGcaCx+SB4YZo3o/pZCcABj3Q91+hrHT4hV5ljdMmfh3vPhwmhUp4eaXlb765hehv8G/672Rpy4VVgy10WZDPTi1NOE7t5RJ3vJlkDGvvenH+Fp4gW95w1p+u4aiVy87auI/AWDc/DLPyiuTMYSuCWAsWCN351le8R7k0XPd/MTT8XE1gLEoY5YSrn+WL4vHefKB5enAVVPMxryx1b3n2fbWcJvdzJgSUg8MyEzz/kTXHeXP8PX4Mk9cNCQICZthaREZGBqIjR/Msw6cLA76SJhkZRVH8CvfDb/5Efi/PgCjHX5t+2n+9KNrk9u6GYBxd5Z7PwUwmnz91i6Pnl2aTkd2XLj4VvX9hbcqQGNaLV9SXxPp1UkdXZkT1yoAQwMXTUuzovbppP5HdtO+bMXVEVVNrwZa5NxXAHNmjnG1B4YZA5olIMxZQhJnq52HAWCY+6wvIbFcH1ekQEBx/8VyzGt5CHR0tbqsGkq7kWGWelEnRrUYgTnX6FwNAO0jUaNYNgBDLzZJWc4ANeNV60pIcuB4ofQ9tDeym3gGBQZGHTlGnoExv1YxL5mrYmA4aRx0ZYxq0cTzEFJI6kii8okldUBbtf4Lh/dOMmNU76cUkhMA436oVz7Di/4jXD3bZdmkryUN5JKnTHDm7g/wR/8IfulPwz/+EHzhHxELj98ZPcU7ipnKWkrgqwfn3m4NACPxVeD7PwmfuMk/WfvrCAHffLXQLLg+eE0aUY+lhsf1jX72/3rrsPMqn+0/wJsvreR/z1ixX6hGLo7h9v/P3nvHSXLedf7vqurc0z05z+zOhtld7SpHW5ITlhPG2OawsTEcHBzpMHCEHz8yd3A+/44j+g6MgcPhjG1sjKOE5STJSlawpJU2x9ndyXk6hwq/P56nuqvDdNXMdmt2pfm+Xnr17OrZ6pqq6qef7+f5hGMcLQ7Vat9VH4ploChXEJV+ZQJSczyUFcybipL3vTMozteOgbusWjzNlDrEWE+0UkqkagRU8Xy9KIk7V3rNHQPgrDVUBQZIAMN3BbAZqmv2CCYqJ63Rymdfldpin0Uyr2+dRGjxlPSoUGDuCIm+23igcIBXjffWjvUF8ZsFwn6N+U0xMEJcXM4w1lOHfWHX3b8GXbvhnj9cf0xsULxuMzBe9FIUpdS4ue142s1MxGVH0qcpJfPdRk1IsKR5LxL0aQ1TtmpMPFvhgWF490JwpmhAsxkYjuObrd+F9MrAcDNZdTZmDZkPTqp4CxgmtomnaxSnQzrkxUy0JgKzySaeThPUyzl2R2R9eYjNfr57vGfdMZWRrA0kJA52lRcGBjQGwTYKYFSzfppp+Oj8vRt584B43gqGiFH1YuLpTOtppnzK6eVTdDEjttlGBQ+xx/axWz0nKSVpmVUCS14KKSTbMapXe+USWDPP8SA/xM176wMHEU18OBLZoitla0N16n7xeu4BOPcAR7rfTGK2g9fur1rQa4KBEZemdktpDwv69IJ4besHzc9jZ5c4NBSnvd4XSKANpZBkT2+UM/MOs7qZ5wA4ao7xE3UAjCvST2LhBOTWeKSwm0NDVUwWzYdiFGkL+Lb2nL/1x0LK8Y4Pw4l7AfhG8Xp+f3dX5bgSgFFm3vTFQmy6DB1r7gjPFF9dC5aoPvySgXFFGZxuVV36LjPBXYT9nZVmp1o5RvWKAcHsmnySmcBOOgPxuucc8QnCT7qgN9QZt6wkq4WfewhMg388rKFOTvHKPXUYGIEISjHDYEeIKSeo6lYSwDC1IFMrWd54qH/9sfvfLP5rVIGIADGmn/V+DtvVtAr6NIpGY326GCf+fyP6OYjFrp201aiRtb/n17LFiqapXqlq65resozGXTsO0tDO3o1skQeG7SUhdjubdui61Shpwvn/vMSo2hsAbjGqUN5pbTaA4Zexlq5JDEq54dNd/Frs8ZUMjObdGE1VK4+9icb2kz99B199frrh+vnAQJyHf/N1lV5rVRWqSDRp8Gw4GvtGAIZXGVINgOHKZijfZ8A1Bncj5WRdNLoGIGNUDZO8bnhKLHFKSJoJBJQMlKUHRuMEHvGal0Czm6eQ6mCdtczE0xmjKt/rJYBfbAMYV10lZuDT74FD74S7/zOcuh/FMvlG/iDv3lXVQJbiB8UklMgV6YtfRgNZXXNH4eDbYf9bsWae47efv5M79/TUNhd+Qa3rkkabM6u56iPVVnpRvEZ7yRUNnru4yk/cubP+2GAM8in29LXx6JnF8t+f/w6GovGsNc5f7ajyztD8DgDjCmrkLjwKwJPWfn5ydxWSr/rBLBIL+bbunJOz8PCfip8LKVg8zXT0ENOFgdpGrhSjKv64ki5eHoCxcBylmOGJwh7uHFkfwLii7udWlKFjXXqSx4qv4I699eeENh8lVlZTQc3NVjGLdeFxHjLv4ZUHqp4jtSyFA8Hm2RIAw56TYoPQ1scDX3iEm0Y7KllvdgVjkE+yuyfK+cW09/fQ86CozKUNCobJaGcDBobXGr0djn0JvvzL8IMfuvzjbZfnCvlVUnl3qrTdpLgBGD5VKUlIGgMY4v+tZd3BE18LAYzKRtaDlEAtx6e2wmxOUxXyuiUW8h4M9jZb/+u9NxHyN2a+OJ+JRk2qrakvetjRLQEYkvHSdAaGKmIt3Zu4MpCiG+4xqoL+T1NYErXHthkYm0/UuHu8pyGzwq4KY/E6VSEhacA+iIfL3ymNTTy9gWD2HJDy4IkDEjQzbB+V5rKgNsTAUFVMC3JFdwBDs2NUrdZIz8BrjOrGGBh2hLB9/JbHqLbgM7ZVtS0hudrqhc8KZsE3/1CYyT35EVaDgzyr7Oeea6p262QDaWuxm2akaFdqTmisb/gRTt34OxxdVnnToYHacTLKr8OXR1Xg0krG/djpBUCBSBfPXFihYJj1dzoBgm2QTzLeF2MukWfZjmo9+21O+faze6if7rZg5b9RfWiWHaO6RQ3vxSfgH+6BC4+V/+74l5kPjLAWHOJgDQPDD4ZOPOzfOi+AyafF68G3w5lvwuoF/qTww9y5p7u2qZTeJ+1+cX09MW8a1YQAd56xxrl5ZxXbyAFgXJHxoK2qYg6+9Itw+J/Lf3f+IZR8gq/nDnHnnmoQTGDWUd8WJ/B84efhI6+G9JL485lvohh57s9fy501QJh4rsIOJtmWVGoeMSd1s5Iu8PzU2vqL2mAc8knGuqNMLKW9y16KWfCFuLQiQF63BbGneuX7oWc/7Hnd5R9ruzZU9gLdbQfabljcJSRqSULSqIG0m4TERhgYcneuJeZ3HqUEFSkkHjwfNlp2zKj9cWwVjfptNwzxhoMN2FNA0HGvGzWpzvQZ2AADowUAjd8nPQlcmrgSKGaYkoHhBcAwS7GdzW0+1UppwRY2bl4lJE5QvJEMyQlEeIlbTW7CA6OZbBio8sBwmZtsKU3RsNwlJFKKYXvnNNXLR7MBDDtG1f3ZzxfFs+zGBHFGO5stYoXZt9C0tlNItmsra/JpaB+F4VuFmdzkU/xl4Z28aryPzmiVwZBW3m2FDbrhu1UhI3bgo0Iucv/RWRQF7jnYVzs2KAAMrZhmsD3MpWUvAMaiiABUNZ44v4yqwK1jXfXHBmJQSHG7ZKA8dnYRFk7CzGE+n7mJN19bB1TR/ChmkbbgFsoxHvsQTD4Fn/33ojlaPIM18Qifzb2Ct14/VDvBqL6tZ2DIGFPe+hfwo5/j8Jv+hS8m9/OuW0drx/qFoWy7Jq7vohfvkyf/Hj793vqxjye+ypR/J3TsZLyvypRV1fBJT5OXlYTk+Jfh2U/CF362DIQ9+3/JaVEe5sZaCYImJoNICcDYgmd/bQoOf1rEJH/t/xW6kCc+QsLfw5Pq9byxGgSVoIsNYGzZs59egEg3qBqPnl3EsqjvfwGCgVFIMtYTJa+bTK95lJHoefAFmVoVc2RFBO5ma/R2eP+TgrW3XS9q2UwIt8V3uwQwar7Dq8qvKmQK7lGI9vsmskXXXc5S9GYLkitK1GsPO5fgMKF0xv01VUJClddC0w694apgYPjXb1LVKgCj0TVUHfdSJMo040zL5ddEioabqaJWavi8MUFUGYGptwC0KjMwtr5x8yohiYedUbzejGAbJRgpikJAU8sMDDdWliYAJS/smY2WT1NLTb7b3OQ8T1fZiwQ/zRYyMGxQwu/BSNfL5xVsBob42WhRColzXrDB2+0Uku168SsxDT3j8J5/glt/ikf3/RYfy97F+79vvHasooDqK1Gv56sTOi6n0vPitU0AFl8/NstNox31JQK+oKCBF1KMdoW56AXAKKRLwMeT55e5ZjBen6oNkq6d4IaRduIhH/92ZBbr8b/GQOM+5VW869aR2n+j+sDUtxYMuPQkDN0E+SR87ifhS79IQQnyseLr+dHb68hlSufs37oUkuSsuJeRLtj3Rv72bBcdET9vrLfbFBC7x51+ca7Tqy5NnKHDN/4ATt4HX/kV0djatXgaa+IRPpe9lbdeN1hLzVV9+JASkpcTgHHxcUCBjp3w+f8Iz3wC6+gX+UTxHl53aAc9Ncwjm81QlmO86DVzWLzueT288Dn4+Ntg4mH+IvtWfuCG0VIzVyqt8pzXtoqBkVmEqGBcPHZ2ibagjxuqpUx2SQnJddJ75/ClNW/voefAFy4ZHdfcv+26qspeoLsBGPYit8sFwAj4VNJ5dwmJ/b7JvLuExMmSMK3marBL7vceIwVLC23JIFCaTF+vbnJaQdf2Ws7mLRTwsqNrVPy5XjkZGK2QyNgNc7ZgeDYT1V1MD8X4ygjMZhow+qo9MFokG/JSlQDG+s17zXfgOuWcV9zkZwGfuqkUkmbeC7vs58jNA2MjSU522kxronjFsXK6/Ax6YWCUxrrNeThMPFsjISknTZUlJC8BAkbrAQxFUd6sKMpJRVHOKIryW61+v5d8JWeFBjs2QPaNf8qvnLuNu/b2cEs1pd4uLUBYNfCpysbc8N3Kpn5He5lP5DgyleD11RIWZwWiUEizqyfKucV0w6gpAIpp8EfRDZNnL61w23rsCxDNQi6BT1N57x07uHDkMaxnPsHH9DfyntfdWh9UUf1g6nRGAqykPTADml16XoBA+78f3vI/4MKjmFPf49dz/5G333Uj19VrjDRxzl0Rf1km82JXak4YqyoKU6tZ7j86y4/cNlr/y9gvAIyQlacj4mfSTTq0cByKGei/TjALXvic+HvTxLr/dykqAT5tvYEfe0V9cMf2NHlZpZCsXhJxmu/+uGAIfPmXuKDt5GPav+MP33awdrxkM9heuJ4ijZtdK+fF6w/9Hdz4PqzJp/la6C18JfD9/Pb3X1M73vbyKaUYNXEe20jlU6XY5ifOLXHrWOf6C5mAkLUdHIoT9ms8NVGHUVSv9Bz4giymCvg1hXho26bqaq4SA8MFRLAXlTGX++1sQryYeII7Tbukj5b06+Yu/GWcpmlRNC1XQ7sK74QW7EbaEpJWGIRutJzNW6Pnw74/Obmj26h5qk0hacaZlsuWIqTyekVSRs15VEVJeklicDafTQXRFOXKYWB49D2xAQy36+AEwRoxMMAGPzeWQiKMd1sAYMhzdWVg+Jx+Ge4MDBv4hNYwMHI2A8OD/4s91uuzD9JYuCUMDErHb0XSz1ZVSwEMRVE04K+BtwAHgfcqilJnVb1dnso0ITULMUGx/tz3LrGYyvNL9dgXdql+FFOnLxZkLtFMCUlSvAZjPHRKJIbUpI84SxptXjvczmqmyKVll934YhYCES4uZ8gVzdoYVGe19ZVSS375dXv5i9inWCHG6u2/xvtft7f+v9H8oOfpiQVZ3IqGKDkjXmODcMtPkvmFZ3ln4G852nUPv/HG/fX/jWzk+tt8LKby7iBQKyo1X2Ld/MvTk1jAj9cDFECAVgDFDCOd4cqI23q1Nilef+AvYPQOuPfX4Ym/o/DJd6Ocvp8PFN7Dj77u1vq+AKoPFQNVgVT+CkqVaXUlZyA2JJg8P/cd7tv33/j+9B/wez90e33DXslmiEkwYLGZoKbXSi8KICXSDe/4Gz7+usf5+dUf5/fedl39HWg7OUV6+TRVCmeagu3lpYoZ8EdYTOU5u5CujXR2lpzv/JrKK3Z3cf/R2dLCoWHpOfCFWErl6Y4GG5oAbteVXzaQ4LbT+N47dhAP+UqMnfUq4CvTwL2YeIKHhX9JtiE12C2IUbV34t3SDMpUZ7HYbvZupKpUyVOuEAZGo895NQOjUfOkqpXXr9kMDBtoyevePDDMDQBXzuaqmfR2W0JieDRVbGU5U/Q6I+uzrRRF4eHffB0P/MZrGx7PCYK4AhiaWvbA8JhC4ub3sNkqpS65nHPYwUwKuEnh1NYBVWVQwgMLSqliYLjNeWplConbZ2UzVcFsuwLYZ82qVjMwbgfOWJZ1zrKsAvAZ4O0tfs+XbuVWwdQh2otlWfyfR85z42gHd1SnjzhL84NRoDceYj7pIiGxLHj8r8vxqI3KXvT7IzxxfpmuaICDg/H1xwfaoJDkhhGRBnJ4ctXl+KJZOC1jUWs8D5wVGxB+HPkk0bNfZTx/lO63/TG//oO3r/8h9YdBz9HTFvDmzdDsSkgAIz4EwF88neP5tTB/8sPXr08FlI1cX1SlaFhbQ6XPJyEk7vP9R2e5ZUcnI+slJWh+KR1KM9IRcfc+sQGMjlF450ewor3wb/8P+rnv8Mf6jxO48+f5pe9bB5BSNRTToC3oK1GsXxaVmIb4IADH9GF+6cge3nzTHr7/usH646Wxb5sEA7bk2U8vQKQHFIWlVJ4/+/opXr2vl7ffOFR/vKKAFsRnFmgP+1loJuD4rz8D/3McZo+4jy1kIBDlxIwAb9eVj4Aw8dSzYBR5962jzKzl+MKzU+7voefBH2IpXaC7rbGcYLuu/LIBjDaX1Jzbxro4/Idv5PqRjobjAg4Tz0a7qBtx+rf7k7LsoPkL/6JhYlrudGrnuZgtYGCUGuUWeC1stNyYMXZpDtAA3Ew8xWv5Xl7eOVaX32PqRXVqgxcZU0tjVC1HY9uCBtFrdUfLksC4i0xktCviauIcdRh8hjxISAryGfLKwDBMsyWAj7331hFpfA2cAIcnCUmL2FVaFYjYUEKiVfpluM55jhSSF8MD40pgnzWrWg1gDAOXHH+elH9XKkVRflZRlKcVRXl6YWGhxadzhVZyFp79JzBcGtJ8QrwGYxydTnBhKcOP3rGj8S6dFgCzyEA8yMyaC4Bx8XG4/3fgU+8W1PRGZQMYgTaOTic4NBRvfB5SQrJ/IEYs5OM7p1zudTEN/ghnJICxpyGAIZu11UvwrT+CvoNw0483Pr4vBMUsvW1BFraCzSAZI0R7mUvk+NhjE7z7ltHGUhkZR9sXFufatJ3oqWfgb14JR7/gPraQhkAb84kcx2YS3OPitE4gAsUMYz1RLi5nSl+gdSsxLXbmo71YnWO8v+tvuTv/V/zS6L/y7vd/kN9968H1ASnpDyJMWV8mEhJDh+yykPQAH/y347SH/fxBPemIXfIZClgFIgGtuWwGr5VeLJn//uOj50kXdP7gBw42nj/8YfF5jQWbd87ZVTjyL2KuefCD7uOLafCHOT0vAIzx/tj6Y8OyEc0s86ZDA9yys5Pf/+IRHj+75PIeWdCCEsDY9r+42stegLcF3aOKvbBtKlIHPEpIXBf+zsWt1eTUD3koe97fiAeG7kF6sPHzUa4YJ/5GEgJnlXd03U0BNYdpqtGCBAnnezdigiiKgqYqFAwTy/JmZOgEMJoJMpQYGFdACkmno2FvxrO3IQaGx8QScHhgeEgO2kxZiHvhBmBsZB7zlZJsWuOjAmUZlycJiUcGhiZlbUDTU6DsKs+rjgSmbQaGa9W7QhWdomVZf2dZ1q2WZd3a29tAgvBSri//MnzpP8Ejf9F4XF408wTa+NbxeRQFvu9AndQPZ2k+MIqigVzKNKYxn3+4/PNTf9/4uBLAyGshTs8lOTTUmPoqok4Fpfr1B/r4xvG5xs1sIQOBCOcW0gzEQw2jpEoAxrf/Gyyfg3v+C6gui4MSAyNIQTebZ/z46Ifg715bZhOsVwV5L4MxvvjsFEXD4udes7vxv/EJSUBfSFy3pjVyj/9vmD8G9/6G2AFuVIUkBNo4PClMCW8bW8d7xS5/FAoZDg7FKRpWqfmrW5mlUsrDvS/McO+RBX70TXfzDz91F/sHGjSLUAIw4mE/a9kt8gdpVs0fF8aWp7/ZeFxJxhXn0nKGh08v8pN3jtHRgJqKqglQU4IBTZNPZVfgf98OX/iFSvPVepVZhGg3pmnxxWenefW+XvY2AihB+KlIwLFpXj5LZ8Rr/3Vw4l5Yvdh4vIMV1hHx09OIISGZVSSnURX4x1cu8QvRB/jVGcT8LAAAIABJREFUj36Tbx6bW//fmTr4Aiyl8vS4GDpu15VfNmW84ffXBqqigWzgQeDU2nuVkNg7rs1c2CqKgk9VynpwD40sSLf8FhjaqXK3s2xkt3WL+HWZi1VVMhDcAH3dbtib/fsFPTIw7HPJFrwZGWp2BGZL/AvUK8YDw6epHBqKN5Zbb6Cc98CLhKTez/XKBgNEBG7z28QyA6Pxd1wlk8wLCOZgYDSVxVP5GfRiYOuVgaEo4pwty8KyWjMnOWNUbQnJS4CA0XIAYxJw5iuOANMtfs+rqwwdzj0gfn7y70Bv0HyVmt42nru0wr6+mLtLvRYEPceenjYKhtnYSHH5HMRHYP9b4fBnwGxAxZcAxqWkQGqvGXRpMMOdYrcYePtNw6xmitz7QoNHoZgFf4TZRJbBjjpafmcNXCteT94LO+6E8Tc2Hg8VO7rQJC8A04CH/gSmnxWvjSpf9hD59ol5Dg3F2d3roYkDeoLSC6BZzefMYXHszKJIAGlUhTQEorwwuYqqwMFBF+AqEIFimmuHhOzk6FRi/bH5ZMkk8ROPX2B3T5Sfe/Uebz4Aqg8Mne62AEtbZXDarHrsf8H574gklkafwXwZBPv2CZEK9I4bh9cfb5evDN41DQQ7+TVYPAmHPwUXv9t4rDTDPLeYYmo1y1vqxRxXlz9U+ry6SuG81rI0E339HwAWHP7nxuOLQkJybiHFnt62xs+lDWAkpuHxv6b9iz/GL+f+lvsCv8UHPnkfT55fx9TTKILqYzldcI3U3K4rv2xTzkZRiBupoEcGxkaiCp0mnobZ/AW0qioOPbhHE0/pU9HsZrMkIbkCGBi2UeNQe+P1zUZiGUsSEpuB0WS5RCUDwx0Ys++71whMw3SXyWy07IayzALa2vDFe3/5VXzsP9ze9ON6MQCu93O90lQF3bDQmwxo2nWblL33xRr3L+ENABiaWo4PhuaCYDUgogf5VN4j68w2H22luea2hGRz9RQwrijKLkVRAsB7gC+3+D2vrlq7CEYBrnmbkBWcabDrWmJgxDg2I2QbriWZD7t6haHiuYUGhnUrE9A5Bjf8iEibOP/Q+mNtAEOekutuQtsAJMXO42vGxY7r33/n/PrSDSkhmV3LMVDPjNBZ4U4BWvhC8KYPeIMWfWGwDPqi4iPQFIPThZNiV9wXEgkahQZgkQQwir4ohydXub2Rj4ldkv7fLRkYrpIgL2UUYeksvOIXID4Mz32q8XgJYJyYTbK7t801ugt/BAoZxrqjxEI+nrm4sv5YCWAspfI8NbHM224Y8j6Z+wJgFOiOBrcuoaVZNfWMeE1MwplvrT+uBIK18dTEMoPtIXZ0e9jV84ehmJFshiaBAVNPC7+TQAye/WTjsUYetCDfuyCehVsbyabskgyM4c4wM6s5dKMBewvcmUQAqxPidderYOxVAnxZbz6yLPHsyzlp0KXpIC6BpJP3wbf+K+x7M/z0N+n06/x56O/57c8fLu0CV5SpY6o+MgVj/djo7bp6St7iZq0VAxvYAbd3L928FsomntJ3osmrQp+qeF7M2826DaY0ezEvGBhXRgoJwNf+86v48i/d3XBMdSxjo2vilOC0goGx0V18r0kM1RGYzWVgiNeC/M54CTDn61avCxjgnDtCLqCmT2ttCskf/eAhPvOzr+CAC7PWub6MuXwflo1g7fvcChNPCSI2uCYlDwwPkav2sW3A1vlezSxnjOp2ConHsixLB94P3A8cBz5rWdbRVr7nFVVefBWWzonX234Ggu1w4qvrj5WU8VUjwFwiz0FPAEYc8kn2yt39k3MNKPyJaWgfgfE3iXN5/rPrjy2mQQsyuSZ8O0Y6w43PI9Yvzj+fQlUVfuquXRybSfD0hXUaWikhmUvk6XcDMAB+5JPwa8dh+Gb3sSB2dIHRmPgIuBpMeimbgv6a3xS7tWe+sf7YfBJUPycXC+SKJjftcJFiQAnAaFOKdEUDXFhyOefl87ByofGYzBJgiR3jQ++Ecw9Cbh2WhKGLlIRgjIvLGXa6GEwB0rxV3PM793Tz8OnF9UErCWA8d2kVy4K79va4H98uXwj0HF3RAMtbYUzZrDJ0WD4Lr/hFCLXDsS+uP7ZQBjSfvbjKzetFKVeXPwTFHKNdIhmmbiO90Vq9CH3XwIHvF3NYIz8fPQ++EIcn12gP+9ndE/VwzmHQs+zqjqKbFtOrDYCXY1+C/z4ET3yk8TEzy+L59Icxb3gvLJ9j8vkH6481CmAZWP4IswkPoGq0V0jbnv2kAFjf/jcwehvK9/0eN5lH6Vh6lm9J1kxFmTqGZRs/bkeoXu011CHm7FfubpBYs4GqaCBddiTtJJKYi3zFGV1qWM33TdBUxdPOJZQBBQEymM2PUVUkjdosn9tW1oGBuCuLtsTA8EBJr2WwNOlEZTlNPN2SdTStLCHxezaNbEWChHjvgi4MKV+qyU5ups82gyHkV12lWaqilCNwW2B62t0W5BW7u13vhZOB4cYwseVh9t5Gcz0wvDMwbOBkI6Btq4EFZ4yqZVkoijfPpSu9Ws6lsizrPsuy9lmWtceyrA+0+v2umEovwV/dAP/6c43H2XGanWOw/81ix85Yx49Bsh6mMuJDvcvLwj8Yg3yCzmiAHV0RnrvYIP0juyIW2/4QJ7teS+b5L/HMRJ1Ftn0ugSiTq1kCmkqvm5SlTdLEJ5+ED93Me554B4dCi3zssYnasaYBRp68EiKV1xlw2+0E8AUh4mEntzReHHMwIhDmC8sNmCmGLiQh5x5sfMyE9L24/kdEysKxBmSjgqDRn18U77uv30U+AiUAg2KGnd0RLiw1OOfsCnzkNfDXtwuT2PUqJe9vtA8OvBWMAuZ63guyYbb8ESZXsq4O2eK43RIkgVfv62VqNcvZ9VhA+SQE47wwtYai4I1hZJcvCHqe7miAZF4vod9XVJ24TzTVjYDN1JxolnvGYe8bRCLQejISaeqb90WYWs2yv5GppLN8AgzY2R0lr5vMNWJhzByGr/4apFxMd1cvQfsoHHyHSEuaeHj9sXoefAHOL6TZ0xv19kUqTXd3SobJ+UbP/tP/KLwkHvz/GgMp2VUx3wF/emk/GSvIg5//MKfqgbxy7s0pIXJF031OUhS49acEc+SH/l58DgBu+jGsQBvvCz3Glw/XkdCZOkXE/O7WeG7XlV/vu2MH3/jVV3NHswAMRyPoxn6zF9JeFv7g8E1o8gLauRPfyPwOyrvlZosYGOWoxeZLFVpV1QyMRlG0lQyW1sWoQqU/Qb3yqUrJyNA1PlfunpcZGM30LxCved24Ku73RutnXrWLsF9zlYrZ986LnM0GlIoteIY2Us65y20e00rPUAtkSCVjTncQsWT46cGzBsqgaitZYfYcb0mQeiu9f5pZWysGeynX0X+F1Qvw/GdEE7BeSV8IIl0kxt4E2RWOP71OAyklJJMSwBh2Yz2A2MWVVPObdnTw7KV1GA+GLhgS4Q6OTSf48wu7iFgZ/u6Tnyl9ECtKRgpOrgiPCtdFT9814vX/vhOSM6jJGf4q/km+fnSWVLWBpi4aqqQhJizX3c7NlAQDfGae4c5wYzbDsS/CAx8Q574eOwGEcafqh9gQ7H091rkHKW31VFc+CcG2EgixwwsYYAMYeo6x7mjjc77wGOTXxLVsROl3pKGc9B9khRjf/MJHma0nT5FNXFYJk8rr7qwbeVz7PV49LoyrHj69TjMsGRjHphPs6olWRIS5lvR6sZMbrjgZSSENn3kv/NtvNpaJSbCHaC/sf4vwJZl8uv5YOR9MZ8R12ulFPgIlP4mxbgGATiw2eI7u/XV4+v/At/+48TETU4K9tfu1WFoA/XQD6YsuJCQXlzPs7PYAwoKUkGRKoO264J1lifk22ivm1kYyuOwKhDpI5Ir8nycXOBG+ideqz/Jn95+oHVsU12hNFzRWT6yw1/wm/PYk7H5N+e8CUZS9r+ce7Xs8eGKOYrUUxiiiy6/lbQbG1V8+TW2cVrPBcjYpbqZ9djPohXoN5UV0szdcnV4Ibs2Q4gBTzBZ4YNi7nbaRXbPBmlZUaUfXCwNDjtWN1jRDTtDMC4BWZmB48AFwMDCa2TNXMzBeavW7bz3I8T9+s+s4G/x0mzdAXDNdepI0kku0upwySjcj5LKPSvNlSHaqTsnEs8EDWuOB4SFG1TDLrLBWzEmVIPXWS+eaVdsARqtq9nlQVGEueOTz64/LrkjteBu/91wXpqXwjXs/z8xatnaslJBcTEkAo8NDAxmMlZrum0Y7mEvkmV6tc+ycSJUg3MkXnp3kSfV6TMXH9bmn+OrzM7XjpUfFgleJR/+1pbhH3v0JeNWvszfxJAPmLI9UN7SGaD7Tung83ahxmyrJwEDPsaMr4gIGPCpeLRNOfW39celFiPaAqvKQfggls8i/fO3++mPzKQjGmVjK0B8PejN5kyaeNgNjei1bH1wCmH5OPH/918HxBkwQB4DxoQfP8aBxAzcbz/HnX6/TxEkGxlJBfKl4clGP9gmqvqEz2hVhV090/QjdfAKCMS6tlJtrzyUZGF3S+HDpSpOROI0tn/nE+uNsACPSzbl2YfT1lS99pr7ng7wfF9MbYGSBBANyJcBjXTCgmBWGtCAidtczGDaK4t5Fe0iafg6zj9PfvZcjU2vrjM+jawGm17LegDuoMN2NBX2cnkvVH5dZEnPqK39RME0aJbnkViHcwZPnlsnrJh03vJUR5jl/4jlWqgEw6amxUhBzkidWGNRPQ9rzeuL6Mt2FSU7OVrE9zCIFW0KyzcDYrqqyYxP9muLqgWGUAAz3hb8YT0sYGJrDA8OVgVEVo9p8D4wyu8P5fldy+aobIg/NU8Fj87TRcsZ2uvooqIojdtKDD4BllYCXpjIw5CXI660xpLxayl5jeonvtVNIii2KUfVazrko6rJG1lSlwsSz2SyDSimcu4yrBDh6YB+ZTg+MFlxupweGaVlNBQi3sl4iv8aLWMlZ+MQ74IV/aTxu/oRIxNjxysbSg8wyhDtZTBf48qkM06E93MpR/um7dSL9ChlQfVxK6MRDPtedFUB6YCTAskoa+bpGiln5d6EOnji/zL7RIZTR23iN/wT3vVAHwNAL4AuwnCnQ7cUtX/PBzz4EP/cwjL8BrnsXAD8YeIbvnF6sHCtp3xlDPJ4d4RYAGCU5RpY9vW2cXUitHzE7ewR23iUAmEYpHbk1CLWzlinyBy8IyvCpx75aP/mlkISAiLbd2eW18Syf8/7+GJZFbQNk1+oFkShz6O1iRzqzTuqB/PtiqJNvH59H2flKepQEzx3+HplCfWbMSlHcl764i2wIBKCDJYCS1Uu8em833z23XCvxsKwSA2NyJeON3eEs6YHRFxPPylyiSeaUXurU1+HstxuPWTorXve/Fc4+sL5MzAFgfPDBeU6Yo8Tnn+YLz07VjpXMqgtJcT88sxl8IdCzDHWECfpUTs+vAwYsnhZSjBveK+YQG8irLpuVFGrn009e5Fu5A+y3JvjQV56oHWtZYBRIFFQsayOskTAUcyiKwsEhITOqWykZUdo5BqO3w8Qj6x8zuwqhdp6cWCbgUxm++S0A3KycqPWnkHNSQj77nua89WrkVgBuVM7y3KUqSZ9pUDS3GRjbVb/sJsTNQBHKmne3dUIpYk+yHpq9S+1TVfIlOrX3SFfTtJpuuFi9S3s1NLTVEY5emqeCIcY2u4lz7t67MTA0TfF830vmqjYzpomn7QR13DxYXspVTkTywMDQyh4YrYhR3WgpijszQVPL5wzNB+98TgaGpxQSjxHCilKSfAFoLbje9jRgs5yuBuDWS239k3m11VP/IGJPv/IrjZ3u1yahc6dwt595vgwQVFd2BSJdPCKb+ODeV3Ordpp/O1wHwDAKoAWZXs2VzMFcKxQHLMgnuGYwTsivltz/KyonFtIFf5yj0wluHetEGb6FfUzw9Nm52h1gowBagJWNxP3FB2HwevFz507o3sv3hc9wuHoRL5uFtC4+ZHbcWFPLwcA4NBQnUzCYWG8nOjENHTtg9+tg4tH1PQzyCQi188iZRS4UO0lHhrleOcOXnqujdS/mwB9mLpmj3+turq8MYFw7LOJLj0yv08glZ4Vx6s67xJ/Xi7aU1PjjizrZokHHAUF3v8E6waNnlirHyvuyVthAE9ezT7x+5NXwl9fyM8m/IVs0eHqi6hnU82AZ5JQQyZxHeYqzfEHAYqRdfElP1WMZtaIS0/Cpdwl5kQ1S1Kvlc8Iw8vp3CfBq+pn64ySglPa189CpBZL9t3Krdpp/eaqOGWtR/I7TGWHMFffa8Eo2g6YqHBiMc3S9Zyghn9sb3gOKJmRJ9UrOHQTjfPvEPHOdt6AqFoWLT9XeBzlnJnWxiPIsD/OHBesLuG64neMzifqsFIeni7nzbph7ASO1VDvOPu9wBydnk4z3tRHs24sV7uQ2/3meqo45laywlJyT3PLrG1bvASx/lNuDE7wwWXXtjTIDY9sDY7uqy0vzYZctT3Jz+neaeLaE9aCW2QNux1ZLO4W2h0MrJCRXJ4DhxRSwhoHR5N/PCVq4e2CopYYv4CIhKZt4Nt9o05aQvNwZGPb6wO2+Qfl+tGI+2Gg99bv38Ozvv8F1XKs/25pHL5+y4ac3BoZWfd4tABecMkHBwHhpfA62AQxnNQIa7LokdxULqfV3XS254xztgbG7AIvC+cfrj82uQLiLo9NrBH0q3fteQcAqoK2crZV6SPO7lUzBu6wiPiReE9P4NZUbRjp4ph6AkRVNyGwxhGFa7OuPwfDN+K0Co/oEJ6p3+o0ClirOpWuzi/nRO7hGP86J2URJK2kfGxwARqQFAIZDjmGnuRydruNvYZqQmhWJAqO3Q3pexM3Wq9waBON899wSbUEf4R23cIv/Ag/USxuQUZKLyTw9Xu9lQJ5zIc1IZ5h4yMeRqXU8OVJzgjEydDOGGuDSc+tQ6YtZQOH5GfGs7T14M1aonVu0czx+tqrxk83nmsTturwAGEM3itf0PMQGGTn7KXaqC3z3XDU4Ig66KsERT/IUZ0lAqjdkEfSpTK40AcCwrPWZEnY554DDn1l/3OpFAYKNvVr8eT0wILMEKLywpFDQTaJ77iJKltVLR2plDfJzMp+26GkLel/0yRhVEEapx6YT9ZNhbIPh7r0wcG157qsuKT8rBmI8c2GV3n23iWMrEzxcLReS9zklAYxuN/Nfu4IxwTixLK4baSevm/WZIzaA0dbPp2fF3PcPn11HwpdLQLCdc4spdve2gaKgDN/C7f5zPHWhGsCQDAz5fHoGi+qVqqH07OVgYI5zi1W/g6mTN8V93GZgbFd12Q2kl9ygj/z4rbzvjh2uYLDm9J1oQfSmT1U9S0jsdbVpIZun5i5RS0kFpcjCph6+JeU08XRr7u17VzBa4/FRISHxEM+b9crAkLvnrWiYSzGqL1EPDK/VtgEAQ1MVdMNCN7b+mvXGgp42DGo9MJpvYJspuD/PG2VgKFXso1bMSSUPDKs1c/xW1VUwfb9INfEIfORV8PG3NU4JWDwN1/6waJjOr+O0n0+AWYRoL4+khzEthc9+5d5awzaQsoM4p+dT7OltQx24DoBrlAs8NVFnF9BmPXgFDTp2iteFk3D8q9w+GuHodBVgAKXdzcm0eCTGuqMwdBMA16oTPFuHJaGrfkwL7wyM6hq+mYi+Sq+5VOn8L5uFVFFFUVq0EynTB8iuMN4Xw68pHKsHYKQXBI0+PsSlmGCPPPztdaJupYTk1FySff1tqEM3MGjOcH5yutarQs9jqAHSBcM1Rq1U/ghoAciuoCgK1w63c6whA2OA75xP8oI+yqWjj/P8ZJ0EGl0wQS4sZwj6VIY6Iih9B7k+OMMLU9X3XDTMKwWFgKZ60+iH2uHff1kkMfz01wH48fhztRIA6a9gU/Q9ewzY5RPXUNELDHeEmbpcAMOy4P++A/7XTevLbwDmjwtmzMhtjWUkmSWIdKOHOlnxD/DcUw+VdskqKp+EQBsn5sTnsX9cxALv51Kt3EDPg+pnPlV0zYCvqGC8JPs4NBQnkdPrAz7JGUCBtn6eVw+QPf8Ep2fqgJ8yDWU2H6RgmIyPDmF17eGWwAWerGYySBAsIf1tPIN3kR7x/BVSHBoS7KO6MhIpIcmFuvnQUfEMrZ79Xq3Ph2WBnkXXQkyuZMtRrgPXM6Rf5NLiWl1QNVlUiIV8l09F7t7LqDlTSiEqlamTN7c9MLarfkWDEsDwgGDcvquLD7zzOldgs4L10AIJyWZiVMsmnk09lZLXglFKKrjyl8Cqg4Hh1ty3moHh9L1w8+3SFOeOtRvYIZ8/oxXPX9nEc6vZBFtZtpQs6BJpC5Wxtq2IUW1FaQ7WCDSfyeDXVLJSVt0IiN0IY0qMLwML4s/Nn5PUkrcQMl756rinbnXlz97NqJUJIeloVEe/KF5nX4Cpdejd+aRY1PcfEg3LhXX01Wnp6RDt5W8em2PC6qc7dZJvHa+zE6/nwBfi9FyK8f426BnH0gJcq13k2ExVQy0lJMuZgrfdb4DOXeL1cz8B//w+3rvwIXTTqm1mi8Iz4GJCfOjGuqPQsRNLC7LfN8eZ6mhBo0DREl9gXdFNMiR69gOwV52uXMibAsBI6grtYX9r6E525GpG6N/39cfqU+ltTX1bP//9SYuc5efkc4/V97XICQnJ2YUUe/vaYFCwD/aaE7XH1vPkENfNNYLWLkWBSDmW9Nrhdo7PJuvIe4qCHt/Wz+efmeQUO7lGvcQnHpuoPWYxC74QE0sZxrqj4lr3XcMu8yJHptYqfUFkE7ecE+wLzzv+u18D179bMBC6x7nTd4IjU2uVu/528sxmPQYkgIGeY7gzXP/+bKTmjgjvmtWLjVNcViaEHGr364QsJL+On0R2GSJd3Hdklu/mRmlfOcpnn75UO66YAX+IE7NJOiN+unYcwlI0DmiTPFvtXSMBzcVU3jsIBuIZyq6AaZTAgLrPfnIWor1MJ3U+fr6TMDn+4ct1QBrJwLiQFs/z7t4oyuD1XKddrAU+bRZPQUVV8A7ERmQMZXqRXT1RIgGtPuCYXQFF47uTBeaKYVLhYQ6qE3z96FzlOFMHy2StKLw4SgaoPeNolsEIC5xdcNxLG8AoNEnS1r2XzuIsiVSaRM4R9epgYLiZlm3Xy6/CfvFMuPkPbKScoIFhNJ/1oCmK58V8KQa0RVptVREpJFejiWeuaLgDAfL3sTfLmr12ch7PjQVckdrgMYmhlQwMm8Hycq1RyWr1wt6yU0iKhtl0JkOrqvzZluBkk4EXv08h4wGIrfWscf/MVgAvLWFgiFdLGhhvMzCullo8DR++Gz58V+Od1NnnofeASG44vU5yhE1Pjg9hDN+GNXsEs1DHLFAmO+QCXTw1sUyu+yDXaRf5+tHZ2rHFHKYvxPRaViyiNT9Kz36uD87WGjTqeSwtwFq26H3hH+2GfW+GQAzaRxm88CU6SPLMxerGogxgtIf9QrahaihduzkYnOfMQlVjZhQpIBZRns+luqQ/wl5lmnNOAKPULCit8b+ACgYGwMHBOMdn6hhiyqSHvBblW6eWmAuOMa5M8pXDVcamlgW5NXJalMVUQQAYPXsBGFNnOTlbdf30PDlTLEY3lLLiADCuGYxR0M3Ka+c4ZysQ5dEzS6iD19KpJDly8mQJ5S2fh2RgLKXLhoq91xA2ksSLi5VMhioAY1O14xXsyR1lMZVnPunwkLHvudyZ3zCrp+RpkmdHV4SJpUx9WQTAN/8rfGAILq4jiYCyZ0i4C06tMx8ArFwQLKfhW0RKzdyR+uMyyxDu4utHZzkfGGeXOsc3njldO07PgU/E+u7ubUPxh1B6xrk5OM2R6oZdSso2BWBgQXaVAwMxVAWO1Xv280kIxfn60VlOWSMAJC4+z2KqyvtHAhjnUo40lJ59dOtzzCytVrKPbACjqNIVDXpfYNsARmZZeHcMxOoDGEUR73xU/j7BkRu40XeRR85UGQVXRTWXDGm7xwHYrUxzxilRkayw1YJCRzMkbV27UTEZVha56ExAMorkTJVoQHvJ6FS3q3llP6d12ZybLHuhby+im73jqqlOM0f3RhbKWu2WpJBcZSaeTgaG271RHXIJaD4Dw1luzFif5kyf8ZbEoJvNZ0lse2CIeuWebv7Ta/fwW2854DrWTiG5uhgY5ZhQaP6z79fUEvPNiw+NnULiFkNbBm0l6NgCcEGtkgleDdI5L/US+TUaVNduGL9H7Eg//9n1xy2cgLG7Bbvi0pP1x9jMikgP/zQRQ7EMPvrlOs2NbDDPpQMUDYvgyA2MMMczZy7VNlV6lqwVwLIchnadO9mhLtYCGEYBQ/VjWRtsIN/zafitC/DDH0Uxi7yl7TSn56vBEbGgn81AvzNdonsPY8xULublueRNm4GxyWa2rQ9C7dwQnufcQm2zsFZQ6GgVgKH5BZVegloHBuMspvIsJKuas4JoLiaSYlHgHzzIQd8Uj52t0xCZRdYsoTfe0RWB9lEsLcC4Nlf3emfk9dtY89nlADCEd8fxaqaOPOekIZrbtlHBBBnInqnV3EsGxtRKtuw7IYGXncoc55dqgaXF3GVE2w5cR1BP0Msq5xYcx5aN7WpRw68pG5cN2QwMI894Xxtr2WLtvQTxbH33w0Iy9ehfrn+85fNCsnPTjwnvh+I6kpTkNMSHOKkKptNXvvZvtWMsC7IrWOEunjy/jH/gEACJqWOVu+8g3scfZmYty6Ato+nZx5gyU/kZkb+rpQVZThfo3SgIBpBdJuTX2NUT5UT1MwSSDRLh+ck1Em27sFAYZ7JWFiLlKOeTKj1tAUFV7dojGnTmq5gM4p4s5xXv8hGAtl7xmpyBzDKHhto5NpOoBeTkOZ+cTTLcEcY/cJAha45jlxYr517JOEsUBejSZ0twuvcAsFedrTxv0wYwmsTAiA0C0K+sVCbmmDp5UyW8zb7Yrjo13tcGwFD7Bk2OG1QFA6MFO+A+rRwnN5HsAAAgAElEQVSn6bob6Yj701sQ4ViWkFw9AIbP0RB5TXGxAa5WMkzcGJjOa+vWBPscMarNTr2wr4HwwHjptzzrlaYq/OabD7Cnt83T2FZ5krSq1Bp5WHPP25n81OgZ9ZcAM8PTeZR8a/TWeHeAUyYoJSTbDIyrpFQN3vUxYUS3nka9kBa7iPFhGL4Va+p7wryxuiSzYlVt51PnxSRw6vknav0kCqIxO5+QJpQj1wAQSk3WNlXFHCnZyPaXAIwxevUZZtaylbuXRgFdEYvnDe1Qq6q4DkM3gj/Ca0OnOVsNSEgAYyZd1VB376G3OMV8ovZc8rZbvpc413qlKNC+gzHfcqUGvwRgQLxVAAaIRi41B6bJNdKp/cRsNRggrtOZVfE8REeupdda4vSFyUp5hQQN1nRx7friIcFg6RzjUGiB03O1AFDGtI0MN3Av4yPCz+Txv2Zv8ikCmlorNZIGjbNZcfyuMdEw71Tmao1K9RyWL0S6YNBp7yy37wBgRFlgwsnukD4VKzlr8ykMvUI2NK5OVfoSGLa0QKEzsgF5il2OVJl98l6erJY9gbh2elZ4Kpz5VqmRramVCSF5Gb1dNK9zx+qPkyyFDz2RYsGKk7v4TC0zILcGlkHaF2c+madrx0EAdlozHKnxAslh+UPMrOXKAEbnTrqNeS6tZCp9M4wiphbYuA9NVAIYyVnQCxwYjNea9IKYxwJtHJtJsHuoDzrHuEabrPXmkeDOVEqlLybPuWu3+B2VucpnX84zy3llY8+9lJvxz++D/7mHNyuPkcrrXKqWChUy4A9zai7J/oEYdO1GwyCSm2Eu4Zh75XmsSslSr33ekS4ItTMeWK5MUDEcz34zYp1tAIPl8nmZBmBRMFXCgZf+V/N2bbxiIT8fft/NfPQ/3Na0Y1amkJgtkW2UjfXcDO3EqyGNNpu9G6kqirC/aVGT04qyr4EXCYTPwdaA5ktIAL7966/h879wp+s457m6xf7aJp7FVgAYJQnJy5uBsZEqpZC0wJOkVeVMToHmg3dOEK5hCon8f1mvEpJq0LGFEhLTNmq+Su6pW718Vkljdwvnf9Oo/X9JKe2IDXLfyhBKPsF9D9dJDcmIXffnlnycNgfQFT+7zYna3XjZQJ5etQj5VbpGxOJ7pzLL8RpZSJaUXgtg+Mw8vaxWJpEYBYpI1sNmGkjND/3Xso+LnF1I192RnElZlQBG+yiapdNDgpk1R7NnFCnIc7GNxTZV7cP0scxsxbHLevP4ZsERL9V7AI7+K3xwhJtO/BkAJ6qp9PJenlwyiYV8xEdE89lfnOTSsqN50sV9WpU7uqV72bWHnczWNlp6jqwpfrcNgTRDNwo20f2/g+9T7+IVPdla6YsE0KYyYpLaMbITyx9llzZf2zAXhZFhxXm0C7nAmG+50ptE3pfVgkbbZu95r6AvXqNNM+GkztvgSF7ZHKPHL3ckCxmRoAOcqgaNQHjcALzyFwVoMnO4/vFWL0DnGFMhIXN64MFv1I7RC2AUMAMxHji1wHJkD3vVae6vloplRcO/oAufhe7RfViKyi51hqPVKTLFDLoaJK+bDNq7rB078Zt5uswVLi5XslZMVdyzDRk+9gpAlY//APyPMV4bmeDicoZUvipxpZDG9Ic5M5/iwGAcpWcf+wPztZ8RPQuKxkzKcEgxBJNhlzJb6Uci7/NaUd3YZzvYJiOBFUDh5ol/AOokB0kJyeRKVkiiHEBKBVNJMn5W8ipBX1UEbXyYHf7qubcoxyvNAVXjAsAYUFeYtRkYprj+eVOrMMvbru1y1luuG/Qeo+6hSgZvpoVpNb+p921gJ74i7q8F9HX7d9WNq4iBodmaeg8SEqUSwHDznthM7e5t45adna7jnECEFx8AW0LSfAlTWUJytcghtro0rczAuGzD6hepnCkkitJ88M7r8+z8vIIH359q35oWx6hum3hehVUcvBkKSVKzdXTnEsBIB3r46CnRzD3w8MO19GTJwPjeooqi+lC697BbneN71bGkcjf+7IohjBG7xSJ6rHoRbehg6qyVAAy5+JfGmzuU+Upmgl4GMDatw+7dz2BhglReLy+cQexIqn7m03olgFGiOi/XgCkFycC4LLO5+BBd+jwLqXzZjNJOIdHVDeXeb7jG7hKvxTTh7/0t18WSdeQYomG8kFLY0RVB6RwDYERZrIxxLNo7y+J8S8acHaN0GQvMrObKz5NpgKmTlSaoG7p+1/47GHsV3P2rYBn8cOip2nOWoMtkSiHs1+hvD6F0jnEguFQrBdJz6KoADErUeH8I2voZD67U3YVOFC/jnrf1gy/MNaHlSnaHYTeUyuY8VULCjJLcKj1tQbqiAU7XY2CsSePM694lhp9fJ840NQ9t/fzZExlWrSgzJ56o9CqAEjtnoeAnUzDw942zR5urjZ/Ni/OYzonrO9bXidKxg2sCC3XYMznyiN9/qEOCYB2CETOqLHBpufJ+GIoYG9tI5GZsoOT1QDHNa+c+DlArWStmyCshdNMSkqiOHQyY87VyKCl7mU/mylKMcCcE2tgdqH6GxH1OFj2m2DjrPZ+CX34G3vBHhFdOMsRiLZOsmMHQQqTyumCwOACMCq8YCTgu5VV6Y1URtPEh+pXlKsBWgnf5y4xQtSsYg0AbO/0J5u15WM57eVNpqknjdm1Xo2p1coVzsezVhNLeSW32Yr4UqWm03iOiWWVfk5zuwcSz6l5uZaMS8Dkp9+7AlS0hafY9ccbQvlQat1ZXmc2w9TGqXkstMRlawxpxfvYaJbnYEpIyA8Pt2RevrfzMVsSoWtsmnlddffS02P386L/eW/s/UwLAeCER5qQ+AEBndqK2uUgvQaCN52fzjPfH0Lp2sde/WBvnJyNJp7OakBKE4hDtZX9ggfMLtYtoW/df2nluHwZgUKmWVuQpyOSKDTUszuo9QKiwQheJymZIz2H5gmQKRmUko71TqKzUABh52YCHPeRKr1vxYcL6Gn4zx2JKNAmlFJJiiwGMO34BfvSz8LMPgWXyzthxTlU3ZxLAmEggdr06yvKKikZOggaLBXEfS1/esUFCRgrNyJTND+Xub8bwEQloG5uwoj3wk1+Fe/4L9B7gxuJzLCTzlbvnEkBbKvjoiUk5RtcudjDHheWqJryYpaCIRrlC298+yqi6WG6uoAxgFBQim414VBRoH2GHr6qxlddkKQ9dm/HXCHWI16wwpx3va6uM5rUrMQ2Rbs4UOpixunjgoQdIVvtQAOQTmME43z61wGxwjN3qDPcdmakZA3BBmlfGh/cTt5JMTk9VyYvKEcU+VWGkMwxde9irzTFRHe8pPXFAypCgFIU8oixWNtV6Hl0yMKIbuR+KAv/+S/Dzj8IdP0/3/HcJUqi9XoUMaUucw1BHGDp3EjFTFFIrLKcL5XHFLJYvxGKqUJaQKArEBtjpX6sCYcteJxs6Z4BwhwAkxu4G4HXRC5UsHnnOefk8D7SHoa0Pyx9l3DdfxZgS57GYU2ojaGODdBuLlaCjfPbTuuIaH+i5YgOM+tdqGBg5U91mYGzXi1b210/eaI17v3MB76oHt3cKzRaZeFbRta+Ghbx9DSzL+26urb/fyubT2fC5SkiktKdgmE2XkNjPn/AQufLv95VQmqo6JCRXR5vo9DppBQgQ8Pg8lxgYBfsz6P7sQxlUbSWAYVlibn2pfAyujifzMqugm3z4eADDUjBnX6ikxQOkBLPiiXkfWa0NI9LHHmWmVhqST0KonUvLGXb1RKBzjCFrjqPVAEYhA4rGQtqky2ZKdOxkt2+xUkogd+3XihrdUccuYFs/AP3qWiX92iEh2fDi3y5J7R5V5isBCT2HKaUEFeZ6sSEABpRlplcrJSR5UwAMl0XVknKFQWW5vJCXzUKqqLTWzE7zwb43weANEO3lJk7U7rJLYOL8msFwR1iAUeFOxoPLVSaU4twXskp5FxoqzPom7estx2Ys3+bvI8DwLfSnTwJU+klIAG0h7ytLjTrH6NVnmVzOVDbXeo683MWvoMbHh+hluZKlI+9LHv/mJSQA7SMMsFhpXqiXGRibMkkMSwAjJwCMff0xTs+lak1zkzMQG+Jjj01w2hxmWL/IF5+brhyjF0DPsaQHWc0UCfePs1eb44lz1cwKsfs/k/WhqQqdI0Ie01ec4rzTLFUCSnNZjb5YUNAP20fotZa4UPO85cghnp/SvZOA5pC6xOxaJaCpswkAwz7mwLUw9ipUI8f12gUuVoNbhRRJU5zDcEeoBN4NK4uVv5+ew/SFMUyrEgyIDTKgrtYFqtYKysYZGHb1XQOqj1tDk5XPPUAxS0Zev8H2ECgKSnyIscBaFYAhnr2VglrL+IkPEy0uYxoFlmygRrIjivguTzLnrEg3XUqKlYwE0BwARtD/svhq3q4roBRFQVVax8BwggR+jyaUIg6xNTGqcGUwFLyWswFyO99aNs3WzSNOBoZXH4BWyDzsa1Awtj0wvJaTtXK1yG7sPqRgGC157m0WUUBTG/Y8NgCX0w0UxbuJZytlbfYhW2XUvFX1slglvTC1ykpBIxkZZa8yxcOnFyoHyBjAF5ZgT28bWt9+rvHP1uqrC0ksqa8e7RQARtDMomQWWcs4dnGlDns5Uyyb68UH6VdWKwEM3XbC91VKQsKdoPrZEUhVmn7qhRIDY9MUfgkYDClLTDuboWIOXRUL/woJSVsfKBpjgURNM5uzfJe/GxkV6QJdJMo+GLJZyJgtZmDYpSgwcB2jxQkSOZ3VjGN3uZDG8kdJ5MwKSv9u31JlxGjRpqRrldfPwWApjbd3cw1t800cQP+1BPNL9LJaCbzIhnkhrzmev2H8Vp6IUXUfi1nyVpWEBCDaS8xYZSGZLwMe0r+gyGXe9/YRuvR5FitkQ3JnvqBuPIEEREywopYYGHt6oyTzOgvVkZ+JaYgP8sjpRXKd44yr0zxwrD6zYjYv7mO4f5wea5njF2YrAREpDZnK+hhsD6H1ClnGTmWWswu1gNJiwVdxP2L6Msl0pjKJpJgla0mjXruxDrSBL8yOQKpK9lWgKE19N3XNAAauA+CO6Gxd8G5VF8cfbA87pCzzTK1WPkP23FEN3nWbQnpWum4SwMhZ/s2Dd74g9OzjgHqxloFRTJORz3Mp1Sk+yJC6VgnQFMsARg1gFh9EwaKXNZbS8vlxABhNk3eEu2gnWZ5vbA8MQ7k8Vtt2bdcGS1MVR1Pf5B3wDXhglBbaVmsW2lpJb371eGA4b8eGJSRb2HwGtY1JSADyxeY3n873vlrYBFtdZWPJq6fZLZ2z3hqGgf3ZayQfgfJ8VzQsV8AWXpzkoGoPjKuBeealXhaf5mcuiKYm0r+XPb5FnqiJAVyDQBvnlnLs6olCx05G1YVas7pCGl2LUDBMSQMve1VUxE0WM1j+CKm8Xt5FjQ3SaSwxvZorN222E76uVS6iFQXa+hn2r5VlB1BK/lAVCG12h04CGHuCKzUMDEM2IRU78aoG0V6GfWss24t50wSzSM5QL383UkY6dilJVjK1u50vCoAB0H8tXemzaBiVjU4hjeEThmklU8X2UQZZqASA7HSF6oZIMlj6WS6DUXJsWr/M3dw+Yca4V52qlIbIhnk269hdjglWT5+yWrMTnaUOgNHWR0RfQ7X08jNoFLAUDZPLvO/tI7QVl9AsvSwbkuBIUt+EtADEKi/UIQwzCxn2yLjBs/NVO/TJWXLhfiaWMoQGDxEmz9SF05WsFAloTmX9qAp0jApmRUd+inknoCg9MC6kVAFoxsvSrwp/D5uBkdPKMrG4fC6UlUrgQM+SMcX7lmRiigJtfQz5U1W+DPnLZ2R17IBgnBsCU5XPvWmAnmO56Kc9LMGG9jIDo2LuKGYpyrmjIp0mNkBMXyRXNEjbSU0SqCpcLounazf9xiyLqSr5VDFL0rAlOBJMiQ3SbS1xaSXjAFJszxq11tMi0iPeQkmybD+fEnQs4Ls8zx9nhTtpM1OsVLE8coZCaBvA2K4XsVTFAWA0eW3rBES8SiDMFu0UVktIrobmzNl0ezXxvBI8PvweYyehkoHRbONRJ/vjarjfV0I5nxv/VXLNNMez3wrjUb8ELtzYkc5nzMvzVmaOtG5OUhzzqrnNwLi66uxCiu5ogEDvHnYocxyfrpJ85NawgnEuLmcY64lC+wgdxjIXF1YrYwsLabKKaGJHuiLQPgoINkN1w2JIOUZpxzU2QMhI4jdz5SZE7tqvFbRaU862PvqVtXKDByXfiWjAt/GYSbtCHeCPsiewxsxqpYlnUZo51i7ou+lR02Xdu/SoyJra5TMwHABG6fiyWSha2otnZtczjmoWGVSWK2n9ErQCBzMlNkiHsVKpkXcwMOJhxzWJCU+VQXXV4YFRbtYvi4EhDUX3B6vPWfw8k3ECGIIJ0qesVko3iqJhhmoGhmziSDqYMXks9TIZQCBYPQjWTelc7MbW8m3+mnTthqf/ET44wg1n/xYQn/1SWRZkV1gyBbjRPiISRrqKM5VeFBLAmEj7GO2KEOjdCwhmRYVPhGRqnEuowuQy2AahdsYCa5XMAAl0zOe08v2wmTksVYISMla5IxKopCm29dGvViUBORhZbZv1xFEU6N7DTmW2BrgDWCn6y7KQSBeofob9qUr2kZ6lqNjgp/PZH8RnFuggxWIVeJe3/Js/Z4DOMeL5GcCqBFMKGVKmn1jQR9D2kYgNEC8KIKUEdqwHONq/J9CpJFmsIyFpHgOjk4iRIJHTBYAm59WMoW4zMLbrRS1NVcpNfYtiLMG7lKAUo9p0OYt4LV4BDb7Xcm7iup1vmcmw9QBNpYmnN/PWvG42nSXh22BDuV3VTfjV0SY62UetuM/BEgOj8XezoiglEM6L/EZ7kWRtmqoIad52CsnVVecW0uzujULnGBEzzcrSPNmCI041v0bRH0M3LXZ1CwBDwaLbWqrUb+dTpBHAxEhHuNSc9qkrlQ1QMYOuCaCjtOMaK++4zidlE9JoEd3WT7e1UsnA0PPkLtc3QZoo7tSqfjc9R6GeFwJApItOJenQg4vXjKkSvdzFvAQw+jXHTqSkUr+oDAyHOWcl1TxDQbXBKHld2voIGwkw8mWJgryXi3m18voFY6AFGApkWCqxDcTYpL6JJAZntY+AonIgtFKzIw7CxLOrdM6SgcFKpSypmCVt+gn7tYoFB1EBMvQoayw7mDHmZkwjq0vKhnoUh5xFt3e4/Zu/JoM3iFfLIPa9v6EjYFT6lBSzYBaZK4hme2CHADBGlAVOzdYCExfSPnZ2RyuAyopoVumBMZnWBCMLIDbEmH+1EtCUPirTGdXBwBBsjQFlpQziWBbogkFQA2hG++i0qswzjXzJSPeyAKWOHfQZ86xli2UpnDznVd1Pp30ukgmyI5CsnDuKDh+VUCWLB6BbSdSAd/nLZTJ07MRn5OhlrTKCuZghaQbpiDpZUINoVpEOUmUGjfwM5qxAnflOzEmdJFl2so9QMGiirC3SScDMEqDIWrZYivgWDIyXxVfzdl0hpSlKy3btN8MgMGSMarPp1FrVbmezAZJWVMX18+ghUjbx3Lp5xAYtPPkAtNBzYSNmotslaiOyryulnM9+K4DJkPzed5OQQPlz5+U87CG63Axt1ZykKlJC0oJ0p62ql8Wn+dxiit09bSXJxyhzlQkSuTVyqkgpGe2KQIdoWIZZqtqVTJGRAEZvLCi8KrQAY/5k5SK6kC43vZEyAwOg39lAFstRfh3VRnJtvcTNFZZShTLt2SiSM7XLl23EBuhmtQxIABRzFFgnkjHSRbvlZEjInUJd23wahV2BCPgjDPrTjka57LUQ9rfQxNNZEsAYDyxXMhQK6VKqQUkOZDdmJMqNnLyXSd1f2cQpCkS66fely3p66QOwabmEXZof4sPs0KoMMYtpLC2IiVrBAAIY9q2Vx5oGmEXShq8WQCuBDGsOinsBU7J0Luu8SxT9RPmzUJIW+Da/M//a34Y3/BH88D+iFDO8tf1CJQPDlobkAkQDGn3Du7AUlRFlkZNOZkVOABhTGb/wdIh0YWlBRn1rXHQCldIDI02ozFKIDzGoViWsSEbMfK6WETOoLjtiNAtgmSR0jY4aQLOPuL7CSqZQlrtIRlbYv8Ekm+rq2EEsJ9gMJUBJMjCWi/7Kuamtj0EtUQOY2dGv7dVePgggYLEKvMsTuEz2kUhmGVXmHSyeIphFErqv0phTPvsDygrziVomyHoARlcVaGupPqCJKSTy+rSTEvI5o8zACG3HqG7Xi1hqhQdGa0ADcF/8l93yRYxqs5unahPPq4GB4QRx3CMZqyQkW9h82hsiXlJF7NPMF1uXQgJlGcB2NS4nC+tq+IyAU4rRmgY9IlmRAS8ARomB4T5WVV+cOUlRFBmjus3AuGpqLVtkMVVgl2RgAIxW77LnEmQ0QSvviwcdO66LlX4BhTQpM4imKqJJVRRoG2DUX0XtLmbISwCjzMAop1FU7wIm9DoNZLiLsJ6kYBgkspL2bOTJmpfJwACI9hI3VllOF8oSCD1HDj8+tY6BXLiLqJlgNVMU/h02A8NoAgMDINJNny9V0SgDFNFePAZGfARQ2BesBTCyEsAoNXKSzdCrrNZQ43PUaYjCXfRoqXITJ5v1tc1ESVZXx06GrPkqb4ZMybejbAQZhWCcnYEkc4lKAC1ZD8CQIE0Pa+WUBL2AUZKQXMZ9KclTEmUDQ3n9LouB0dYLd/0K7H0DAK8IVgMYwgtnMhtgR3cUxRdEiQ2yP7TC6QpmhQAwLqZ9AsBQFJT4ILsCq5WRoFIakiJMd1sZwOgyFplN5MrAYyGF5YtgoZYZMaF20AL/P3vvHmTJdd/3fU4/b9/nvHZm3wAWwBIkuMAqXJB6VCRAIijCkiNBkWNZospVtiwxEgVXaNOyoqgMKoFpxgz+kFWxgzh25AoTx1ZJoUiQkilXBSlXhXbgKpgQJQsiCdoECXIXuzsz99nv/HFO9+07c1+z2z137kx/q1B3gGn0PXP79Ln9+57v7/vlvNXddz22fWN/MkZ9EyfYRotDuVsPEEgj3btqxQBYuQc9cjlFpr3IyxiPZkmJ2iZrbI+2tgV9+rEtl8NscZ+2YnRGfFRAeUncrfoIuZ6mY86oRkbboVTLktjNKKbkq8sewhFUJK+QqqnufvVRbmuSIjBWRJftnj9i4lnGqJY4TOiawC3oATp7vlk74MMWEtlGUlQiylLFqGYL8DlbMY4CQZMUevOMISmYi9g9zxop5u2vcVyxjG03w7lfTHKKcwAFRnKfzjX3D2lN0lVUcRHpTovCsScwiOG/eu9lvvv+9RESYcQzYLBDG6nA2GzYqbz7on5zNDXE67ATVVirZfrTG1uc1vb7CgzY03ZQGxrD7VVgDBgjGXdW0GMfh0ybQujRD7W7N5GrbVALtwmjOFMMDRjEJo3KGH+N6joVfwdBJIvZJOY0yMEDQ51/Q7S5lRTK4QJaSAwLGme4R781LCgB/B59KtSsTItFpr0iLeTUtXSxxvbUr5Ip4lSxvuOJO0+PSNA8w0p4i1tdL5WN4vcI9T0EBkB9i7NGxndiKoGmiiutOyQZQo9A5NFCIu+Fs0aHW91hMQ45FLYgo25XLvIg/4E3dzKmuRkFxpnWMFHmHv3maFyxUmDcjpyhsqJxlrP6nkhQt02oO0RorNeH5px1/yZR4MmiFOT1SAilhNBUypyzZpdv72kp2/H1/YosZw1BTJPu0Ew3dBlEd+mjAilhe07c3EcG3HD1PXNok2Z4m1vdTDqNP6AfS9+JEfmjIwmMFTE69yNhEKPd5RyS9+BFu51RjSgCYy8BpIiUNdpDtUtm7d0393UDKi22zB43M2tvmMz9nBUYK3TkPRYlPht6aeJZ4lAxYuKZc8GSmN5ZhjbTuyupz0OlwMi7/z45f5JCsgy7y9liY3Yrhnw9CjGxlioi5ymWUg+MAhQYpjE/gVZCIjtv8r4eRUHPzP0i5n36nTzHfE7Wlbk8MA7BxBNkC0kYxUTRqK/OMuOY/BmT0aqa/NX3Psgj51dUy4fNvdbuqLJisMNO5FAxlSeBWYFKi/sqneFxUahiBS3Wa6NF4Tq3RuMNvWGUX/ogrXb1ztn9fWkUYx+iU3lxl52+J4v6OKIX5tBCUtvACjpY+Jm2hgH9cf3gANU1NCIa9GQbiZI6d/NIIQFwVmnS3afAkP3mh9RCAlDf5JTYGRY5AF6HTmTvk9EDnBI7I4VZjFA7uvtbcJrxbsYDQ7WQhHmoaTap+TcBhvJ4r4u314NFjWNN62SKVGUi6+v7r7vdBGDTdDOtQy4BOXguVFZAMzhjZskRl1CzALG/helOsPVOzgy+Qhhl2iIUgfH1nslWErHZusDp6DpfzyorlAKjg8NmI4niPMup6C3euJ2JBHXbeIYkPjdqiuiobyGIWaM9VGV5PQJFYKyNFNYbnNI7+xQYtzxtVPUA4KzI4YruCOkjFVl3eQ/Wh4RcquRRCoydYO/c36Lm3yKOo2FqkN+jF41rxZDEwVmrN+KBEao2pLsiXqprKt65w7d2ks9PrtU398ZSq5aQDb27T4HhYYwaj2b+n1NaZ0jwRn5KYORm4mk1AKiJvjQXVR4YATpO6YFR4hCha8U9QCemd/Y8cuo9KSRFKTCSAn8ZPDAO0oKTNcOExXpgJAXfPJ9xMjXcIMp999wYUWCU6+o8GFFNLUnbTTaBpwhiMtlMteaYn0MFxuzPLuFD/KBYUlXTRBqjuiyqmllYjpmZF4SA5hnusXaHCow4BneX25EsVtIdgtomZ4xMEaIejm8F1nC3FaBxmlZwi+2ez8Af7oB3IotmxRgumGpX74zZHRYJyS5gbLHi7N1xHcqLd/p+2nbQDXNoO1D+BmvscqOdFCEDeqGxX04NQ1M7oXYKUwVGTgSD3aBGf4TAkK0K4vAUGAD1Ldbiba633WFrjdejHVlDJQ2kBd95M2NO6PeJdBsQY1tIquEufT+U5rFp8WTe/bWsb6zWTuMAACAASURBVGKGfaoMhuawfg9P7FEAqXG04kxffxLj6+vjd6GtBqeM/lBJEPqpAqN6N0Vz6gvSGfqeZArbu/5MANYuUe+/AcTDtg9FYPyHnsXphMBonqEZ3ORW16WbJFQMdgmNKiH6MIqzeYZm8BYd1x+2dHkdXE0m1KRrglKXrIuM0sXr4Gt7FBgAtXVWaXOjPUoo7QbmfkVWRREYdEcIpV6YgwJDzeeLVntfC0kfe5RMqW+ixeE+RVEnGkPCWnXQTLaMXmYOuUMC426IKhXvPKIoStZozxglXdRaetbqjZDHgSbv133jVv/PCp1M+55PKOR4c1uTbNm2WGdAexCkxHBQKjBKHDJ0IQpL5rDnjB+EYbEexTFBmP9O6t4WkmV4kM+2PcxKQMgmMcBiPTCS76WU8J+CRGnjhQUoMPTlK8YXjex9sSyqlWTMflCMB0bSWj/P/Ezuu3naTdJxF2wsrAmREsPL0Do3D5ZjZuaJxhnO6reHrSF+D6KAt3x7KBcHqG+ywc5wV1slDtz0TNZr2eO2qAS7mARDI09V9I7sfoPc1dO7+1JIxreQJARGRz78K9KgG+ZAGlSHRVZWgdGNzPG73xmp8+4gSMfSz8sDo9LEibp0vEASB1FAJHLuN58H9U0a4S2CKB4W1n6PndAclaQbNlgNzpiZZBG/T6ipKMm9JFB1nUqwiyCSZFRm97ee4+55uhPt9YYtTHuk9LVol/YgkItluuM/poUEwFlhTe+PxNv6GFiGdvcPGdV11rX20F8jdNMd7rsuyAFW70UPXU6xM4z87EsPjN24xunWUDGhxz5NukOiw93BM2Rxeao+bCExIo8WXd7YVmuH26YvqthGJpkiY1D6rUxhnRrBjihi1mlG0mMkimQCCcj1YD8JllVgeBBFEAV08yAwFKF5j93ZRwb02KPAUGTmiujIuR/H4PdpjyM/hYDqGht6d6RVzVeJJdW7LdKVYipLIgL0YnvUBFU3wW6yZXSHREpKYIxJXQKoNKnTZ3eQzM9h+1RuEaeWnGM1MZDkmfLACA4zPrpECfaaeOb7WJg8xM9TCKUpJFFMFBdnKLpMMapCiLTwnlWACyEQgsL8TA6CZCNiNn0xOs68fSqyRoqlAmM+ZJUDy0L6ZFsxiiDuksCCeWp/K41cncfAdg+pWpQHhopRjUsFxhKjcZq16BbXd9Uuu9qV/bZnS/+LBLVTrMTbXG8rMz61I3nDNUYVGEomvUJbKiviGPwuO4E1utsKUF1nVbS5nUjAp/VhZ3ZcZdE79J2466JXFSzrYnck2rMT6uMVGLaUOtdFn/bAT3cKfYy7TyEBsFvYYYc4hq4XqH5zed5DfZCvb1LxbiGIZCGnrvt2YI3xJFjhlNHPSNL7+KogGueBocUhDXpKTaOiJGOTuj3m8z7gmAFOsZ3Zye/Sw6ZhG6Nf2M4qTiDn+3bPH3oujPPAAKi0WNF6w1aBwFWkSw7XvNKiKTKqm8AjEDm0FiRQqTIXxPWhb4W619tUhy0kqSHrztAHY7BLX6USpQqMTCpLuouvYpU36nZGuZWQg+0RQnOQGsFmWxs2qAa3CaNY7sD7Q0JzvLFkosBwRxRZd/15GTZUVjhntve1kPTiyqgCQ41jJVFghB4Q0w4mtGI4a6wJRXwCBB4+JjVLv/udhvoWq9Ftbna9kTW6H+9RTAFU11jXuyOmsYGw0PYajyawG1TpsdvPEBjoOGYO407fQykw0haSoQJj1k7rcYUQYk0I8XkhxJ+q19UpxzaFEN8QQvzGYY7xOELPEBi5KzAU4TfL/wKGu49RHBNE+UvBtZTAUJGFS7ITmapY5opwFIX308+D9HtpDgbDHEm9yDmFZERNsBzXe9EYUWAsGYHh+mHuJCzApQ35TJi28E5Bojab53t8GCF8CB4YqoVkWda9WViOmZknGmdo+m/hhZHcZVdRiG8OrH0KjHpwCz+M5S6xShx4y7fYqGeOc4ZO+7KwkFGI24E52u8OMo402s0UhEmk4BjlQ+KBITojRa/0nbh7E0+QRdZbHUW6BAM6oTFegZEQGPTlA302SSAPgsFuYIU9NCIlpR4a5h2uB8ZWKo+/vusqginmtm+O9SRY1bqZ3d9BSmDs+wxV0dcUowSGTx7+BbIA39R2hkoJr0cnHkOgOauY4QAbT87BTAtTa1zxWVmhSXekhcSLzXxUMXaTRtwd3guhiy9yiARNsCJjNt9R3c4QE9sEuoOPwenWKIGxKTIJI+4uXVGlbhvD+VdT0Zpkiny3zW7s7CE05b113srE5npderFNzdpTmNY2sIMOBoFci4Lh9di/Hsg5tGH0R1Q8nSCH9UB9DqfELt/eGW0h6WGPzqN0XepKIkcpNXaCSe1na7ToDImAYIAvcmidglQx5QURXS8cKjCwx7TkrbFGO6PAcPGFjHIdS0jYTSpRj46rVGGhn8/9moXywFjTvf0eGCdXgfE3gX8Zx/GDwL9U/z4J/y3w0qGM6phDL9LE8wAFkJ4qMJRbfu4tJPLVWyIFBmR8ROZow9GEwFXtzIv0wEjW+GiOFpLsjnneu+dmqcA4MJbRA0Mv2APj7Wea/Pi7zvOxH7sy89jkfp3ns9unwCiwhSSOY8JoeYjbWViOmZknGmcwwx51enKHVLWG3PDMUQVGfRM76GDjyZYPRWB0qewzRgRUT7iXPvjf9vSxCoxatEvPC2VihN9P+7D37aKqQmErKVgS0iA2794FXxXUpy13aMoZR+yOM3OElMBoiP5IC4kf56TAqEjDyDp9RWAEBEK2KhzqDkKmHeNG2x1eS98Yo8BYpUV3JEbVw8I2tP396+rva+whgPw81AxJGoPVGXpbKA+W/fNPztVWYpiaiX5t7SVoACotanFXqm4AQhc3zmHHX53bibvDdpZggI9595GgCZQC46HK7YwCYxtXtYac3qPAOKPv8M30uF3acXWU0My0hqQKDK/NTmiPmvo6qyA0zprdTHtRl05sT7weq7TlfZhRZDUmKDBOmX3py6BUUFKRlQ8ZsBbf5q2OUjMoYqKPPaoaUUTKutaV650/9FEZv3Y0qSXKI4DQw72bqNwsqms4vlTV3Op4k8esjm3G7YzxaB9XjPmcM+O2ww5RRhXmY+RLLOgGGBVauksn44ERolNZkofGAvAjwG+qn38T+NFxBwkh3gVsAf/ikMZ1rKEVGKOaEBjzeCEk9XaSQpL3WNJiYYlMPCGrwJi9/uhHTIGxmXzXToF5gKjYg2IkUePkrqsHQja6dx7z3aOAoQIjKqQNQ9cEn/hzj3L1wsrMYw+imErWvECpwookMGQKScySXNKZOCZ/xgGgitTUZM+TCoxu7IwWLKowXGdXpgSkkuo9BUtqcJkUIfIh+i3PGOOBMXzgTiT8vrCoWvpInx4AVg00g1NGn53eqG9CLjGTwJal/A2SOM1JJp4qkWJNd1UBPmwhyUeBkRT4PdWi4hGiH67/BYzEo15vD8CX17xLZYwCY5V61GZ3EMidK7/PQNjTCaC9LSR5mHiqIviM1csoMLrsBhZr+8acqIXaowqMcS1MAM4K1ahD1wtlZGbo48Y5XZdKCyeUpKC8Fzy8vApbAKsKdosL5u7QA2OwQ0/UqZja8O9V68EDTo83tocKjO1o73ogW0jOWZ1hSo3b5nZgs55VZGkaOGtsGZ0hgTHFEwekeut21xtpIdmnwDArYFTY0JUvQ9JCkkeMqvr7muFtvFD5tHhdfM0mQhtVMySGmHZfKs6CxHh0QhuS3cCJ5LyPldLLzYuoctbQIxcbT6pdEgIjtvcTjtV1GtEOO/3Eb8TFjSd4/qhxJ6qwXUUu+LGRX4RqAqtOS3clSRIl8dEn2sRzK47jNwHU6+beA4QQGvA/AB855LEdWxhakQqM+edyqsAII+I4fz+OhLAoape2aMzbU5+QUXn7SRwEl7fq/Pzj9/O//cx7Zh6bVYoUeV1KBcZ8yJIWy6LASK6tW1CM6kFwEOPivcbCRakjEg+MMoVkmZEYWKJM9pQCo0NlXwsJqGJ2d5C2mnRwRgsWZ1hA3uy44MmH6N3QGjVQVMca0YAKblpAesIe/xAtBFh1Vgw3/7YD3QSzxroxkLv2aSvLmMIJ0gJ83XRV8TQcS14pJJB4bAx3O+/a5O+gSMkAFXWrrmUvtvdfy8oK1VDGbd7uyc9QtmJM9xDZ2UMA3XXxqZtpWshwx7/HdmCOmX+y+JTtTv5sAqPSohKoea+uyyDOgUADqDQxgw4Qq5hgN7+d+QSN02yJ23xze5D63exS43QzkzZUaYFR4aK1O6LAuBVURhVZimy4YPXSFpLY7fDW3lhlgNoGG1qbt5IWEr/H7rjrkSHu9raQjDeWXGFN68l7UBGafl7Xo7qGE8j5nKiPPM2hbhujDzCVFgBb5mCfamRffDCA3aASdQmjWLZ5BB5uXkRAxlz4ZsdL79c+1qiJpxp3RSkq5Oc3YDBtvimSt8YgJW29Ilo77DpNTaWQKAIjRDvWLSRCiD8QQvzhmH9+ZM5T/Dzw2TiOvz7He/2sEOJlIcTLN27cuLuBH2Noorhd++Qhfh5Sbvgwn+xG5jqUEbn2sqgvsphvR1eQiF0WWagYusbfeP9DnFtxZh474oFRIMlQemDMh0rm+2dZCIyiTTwPgrSFZI65nCpHCm5rE0LGU0fHKIXkEA0GjghUL/uGpvq9K8PWkFP1jNRtZDfeBTE0tVsf00Jy1urzStcDXxanfWzW9hrJVYYFy+2ufIj2xJSHaLtBy08IDPmN5JFDCwlApcVaEl2a8eIYWzjpJhgOq8mDdtYDI4+e8MznsjvwIQryl2vPA1UQna+4vNZ2wZMLSo/KWD8JO9gFYm52PLb8Pr3YnFDEyaIvVWBoLhEaEVo+BbuzynqkPBeiEIIBtyNjYsvCCh1JuuhZD4zxBIYVdtUutE8rcBlEem7zT4tDqripAkOSIzle88YWa7elquCtjsvmYIftOGPgCXJVr29yJs4oNdxdru9NJTIssFucMVQMcuAhQpedcI8HBkB1g9Xe7khLz7Zm7ldgZLxRbnc9qExRYAA4K6x0u6qFJLkH81MzmL5MyrnRdnlQJafsa8XQdKi0OGX0FPmppWOepD6yQrl27vR96sGAfpQT6ZJJasqq33pU9o/FbmIFXSBmu+ezEgzox1M+uzG+P25s5K8KsxrU++5IComPQeUYm3jGcfzeSb8TQnxbCHEmjuM3hRBngOtjDvsu4D8VQvw8UAcsIUQnjuN9fhlxHL8AvABw7dq1eQIRTiSKbDtIvlvm+fCzCgk5lrwVGPLVD/JvTzkMzENgZFUXi/TAOAhGWkgKvC4nWNl2IGSTtpaFwMiSFotWGBzExPOw2to0IYiUieeiP5+8sBwzM08oBcY9lT5v7gyVFd3YYaORKTAU0XHO6qpWk2E7wVq2YDEdMKtsGV3Vhz00ktu/4yoLWWnmKI914yl92FadptjjgZFHCwlApUVLU20HSrrujjMPTMfeYEUfqN3LRIGh56TAUAX+iAIjp3MfBKqgPGMqBYY/bBsa10KiRT4ObtqG04smEECqGNowvVTBEmnyuHwKuZV9RdxOOKZloTI0gtzbsjB23EnMI+q6h35+xafayW/SlSa5ocsgMu4+lSWL+mka/k0A2R7S3+ZmUBklMEAaWHKb620X1+1DMFAKjD3H1TbY1HbHeOLYe45bpxHtstP38VwXooDbvjFGxSM/gzW9P6LAcIU1PhnDqlNPrsVIFG8+ZIAgpoFSmHhdSdztHTMoJYjy+FDjcDEnJhjpkY+FL1vhlIrnrpOU1JgBVuhKMsXvESOwKs7+L+hKE0FENVG/BQP60XTyGKAheqnvjxvlEGG9733q1FApJIkHRqxRmUN6ekzxu8BfVD//ReBTew+I4/in4ji+GMfxvcBfB/7JOPKixPzI7trnXfSeackd+L4Xzjw23Y0syI9Dyxj9FRVXWCTm9cAY9/NRhnFICoxcnl1OAEYIjCVpu8mqeBZ9bx+khUQckoln2kISxQv/fPLCXc1MIcSfE0J8SQgRCSGu7fndLwshviyE+BMhxA/e3TBzhErguGD3ZAuJN2whWa/t73m/aPdkIoU6ztcrNPYZbq6xoXfkDrg37MPeX0AOzRxvK1+L/qTdVgC7QV0M2M6kDnh57VJXWjSQKRBRKgOf3hPeFP2R3V8/r7FkPCISAsOLF6DAMCtgVjmV7LJnkxgmtGPI4kkmlnRCc2oLybrppi0kgTCxdC0fdttZpRl32O77hO7QyHA/gSbHsWl5oy0Lk1pIVMxjlUR549ILtZyuubwXmqInoy2VAmPi/LsTNLawBzeAmG/c7hMPdrjhV4YJJAnqW7SibQCuK5l5m+poCwlAbYNVdrm+6xK7st1CtpTt91uohsrrZle+7gTGGEWWJDBOW64ilOT1MKzqhGSMOtV9SUA5JXqkaoZu2kLSi639Cgx1rIxzzRjBxtZ4I1h7aNCbpKfkrcDYNFS0rN/HExVaexNIMuNo0FOKH5deZEw18UzGnbSQ5Ob/koVVp8pAtmhFw9Yy++TuFP4d4EkhxJ8CT6p/RwhxTQjxDxc6smOMrOI67wfoxDD58unGHONQBENBfhzJ+ZathWSgUkXGbjTswWH5SeSJ7DiL9O04dF+1JUVWqbIs30XZObToeztNDZrHs2ZPtHORLSRhrFpIlmRdmIW7rZ7+EPgx4P/J/kchxDuAnwAeBt4P/I9CiKNxF5gOmDXOmJ00hSRCw3bqo8WkVQPD4azZ5dtqx9UXFs1adX+eeXWNVaH6sNWufX9v/CCkBUtD9Ia7gPGEnUuQBUtcUMFSaVGLukQxdDqSnHGxJo+l0qQhBiMeGF5eHhiWzFeua64y8QwkUbOILxtnlXVNFnFxSmCMkdKrNIaWSHaiZQzt2M/PdEAzWDMG6bUMhJFf4oazSjVqE8ewsysL8bGqkVQJMhhRYAjTHr+zkygwREJg+PTziPGF4b2QGpu69CI93xaS+mm00KVJlzdu9cDd5Xbk7Fdg1E5R9aRS48YNqVhv7zX1Bahu0Ip2cIOIjvqcO7HDxl4FhrOG7e8giLi9I48bjF0PZJF8ynRTP4lAmNSdPedLYNVxYqlSihVxkKcCA2BT73Gj46okmzEkrDq2EbfpuAHeQBJm0xQYkPF/CVy6YU5zX7VEnbOVl4/XZSDGJJDsGUfiP9QNpxG2ivAQ/XTNG0QFqMKsGg4D2pkY1ZCTq8CI4/hmHMc/EMfxg+r1lvrvL8dx/DNjjv9f4zj+0OGP9HghSxTk3T/eqpp88mfew9/7ie+YeWzyaJXsRuY9lrRPPlguE8/kmXPfd/oYJASAJhZfyM2L7LN3kdelVGDMh6wCI9dNpQKRJe4WrRpJ1pl9ZuJjj5WvXtEmnkmMalwqMACI4/iP4zj+kzG/+hHgn8Zx7MZx/DrwZeDdd/NeuaK2zpbWlgSG12GgOWzslYsD1E6xqbeVAqPLQDjjJdXVNVrRrlQzuMNd+7UJpn1r+kDuAvp9etGUh2hVsLhBhOfJgkUmf+QUY6lSINrdhMCYLqmu0duXQpILo21VAVgxgowCowC59jxwVmmJLn0/xO3J9iJPVCbG3K5pcic6DgZ0Qp2mM8GQ1W6wqg3SYj3AzK9Yd1ZTA8adHbnjP9a3Q9PBqrOqu0oB1McX1vgda0iJJanA8IlDj0Fs5kMsKQJjVcuQeaGe7wNG4zQA91c63Lh1ExFH7MbVYYRqgvoWhnsbnZCbN98ClAKjub81pBrcBmBn+xYwpqUMoLqOFoeSnNmR16UfW/vXA8OWySLGMA3IE9MVWZWoRxDFuG7S9pWT8amaz/fUXGla7HXZicYYEYNMpwmVuWt3SH6OHXfW36bvE4cu/Ugf3yJzh2M+naQp+X0G2BP9XACa9Ljd84kDl240hfzZqwqLfEVg5Eyqmg5m7NLzQmK1rgZCX/gDWImThexDcxES5u95YGO8QmsPsgRDEWPRMy0ky1Lcw3And993+hgkn9my+F/AKGlRZAtJqcCYDxVreA1y+a4+BBj64ah45sHwHpw9jr0pJEXHqIbR8hCbs1DUSnEOyDqEv6H+2z4sxCW8usGq2KXtBni9XXo4bOwtQgBqG6wje95jt0OPyn65OICzRi1qE8XQ68oH+7EP0kl8qe2m5pmdaQSG3cCOlKKjL3c68zPObGElCRNKgTGY6oHRpBrLh/lYKTCEYeUTS2XKQnnF8KQCI5Jy7YU48avdZYBuW5IBptPYr7pRBdFZe6BaSAb04ikKFrtBMyUw/PyIKDVm09sBYtpqzAPGeGAA2E1W9IHahR7gisr4gg+GyhgxoK12z73cfE9kgXjK8tnu+cSBRy8y8/2yVATGQ/Ue27ckMbFLja29xET9FIKYdbHLzrZUYrSpsrWX1KxuYHvbCCJ2bksCoxM7+1NIqklcbYd2RxEY4xQYAJUWq7osqvH7k4kAAKuOFck2k35vuB7kY+IpyYBz9oAbHak+aocTWkgqK1QUgdHryvVpwPT2qYZSYMT+ABcrH6LKrIJuSUNRpX7rTSIw9rQsxUmc66RxpKSqr4gXn34RBIZRwYpcwigmCCSBYRjm/vWmRIkCMeKbsMC5t6+FJOexJEXOsikwnnhItjSPXY/3IHkmWxb/Cxj1Lyi2hWQ5ivFFI0ugL0uxO2IEu+ANgGSdSUiJaci2tYFUThUBTXlgRHGce7rTojDzz7jDyLNxl2CsCXUcxy/EcXwtjuNrp06dmnfcd4faKZqqR33Q3aETV9ioj5Ft1zZoRtv4YYzX36UzzrAP1A64PF9fERi209h/46uH6E1T7oDHqQJjsomnFcpCZTAYSsZzWYQrLQxfpmj0erIIcaclGlg17GhAEMX4Sg1imBOk7geFYYFm0DT81MyukN3OeeCspGqGhIxyavX9xyWGn7bHzbYLqiCa2KNqN2mKXuohkpv0H6ShaBxQY0BXFcxjo18h9TKRO/6yYJ5MYAw9MDqDAYIYL68df0WObFg+2325I56bQW2CuiQwHnA6dHYUMbE3hQTSxKEHa326u5KY6Iva/ofF2gZCKSvabdkaEpq1/c7mKnJ1jTadtpxDYz1JQJrpir6MYFYKgmktZWagPE4GksjwMXJVMyQRwpHXpRtPMvFsYXpy7eiqtSMQ1vj7dQ+BQejmN/eFkC1feo+31OfXmxFlvGn73O55CH/AAGvyeqdI1ZbpSwVGUJAvj1nFiJS/kSeJYV3P0ci2RIk5cFSMHzWt2N3IJNXEDaKlihL8W3/2Yf7gw9+731h6DJLiaZkImpEY1QKUI889/U6A/W2hJcZiGQn0Ee+XBVfoT759C5DKs1lIFRiBTAcp6rPXVIzqcTLxnPkUOS3ybAreAC5k/v088M07OE8xqG3g+F8EwO/tshtNIjBOUQteVce1aUc2a+MY8OowgjAhMCq1MYZVVh0QrBtyBzz2+wxia4qMuY6hov8GfVmwaIadz5d6pYWII+r06SsZeKhP8EIAMKvp7q/nuliAZc3+Mp0bZo2m5qWO/4OovjAFhu1LEmDQ3SXAoF6rjTlOEhibZp//r9tFEONOKp4A7Ca1Xj9VYHhxvh4YIONR+7KepMcEL4BKk3pHKmkirz955xxSAqOle/R7w4K5mocCSJ171fSkiWfo4mHSyrWFRH6JXDR3+b+/7YAGu+NaQ+ryuLfVegyUgsWur4zxupFfRuuiTa8tW0nMamv/+yoFxobeodtRBEZss7rXxBOkmW6ny+4gIPL79OPpLWVaLBM9kvXAy6sVKZnPRp/rt1wwevSx2RjrgbGCiAMcXAZKGWZXxngDQUranrI8dvseInBx8/LxAXBWWQ3a3Ox4qWpkLImYqN8sl9e7HiKUhOM+Q+YEmba2113ZPpWraiqBWcGIFDnt+9QAwywJjBKHi2wxn7fvxEGRjXTNeyxGpkVlWXr7QRb4D2zONkGFIUmjL/g6HgTZ61zE/Pup99zDT7774lIW5ovCoxdW+Pqt3qKHMTeydZG14Ll/7d41vvq3/8xc6pVsC0mRxIJMIYmJ4vjY3AdFreC/C/zvQojngbPAg8C/Kei9Do7qOqZ7C4gJ+rvsRvZ4Zra6ju3dlMcNOuyG9kQFhogjGvRx+218TFZqzv7jNA3sJqu6jLGMgz6DGSkkIo6o4Ml4R8DMizTIJKL0VdVr2mPGnMCqYaYExoAAg1qeDwBWlUbsyRYVlOO/uRgPDN3dBmL8foeeqOz3LgCwGoBgw+jT6Q4VLJMJjAbV+CZ9PyTyB7hxjn4PScuC1qHflUInza6Nl9HZTWrtbwPguz3609pelEpi3XTp9ocERi7jVudeNWQLiVCqlFzIkQR2A6wGZ/RtjKAGFujOyn6Sri6VX/dWuuzclsoKp7m2/3wqWvmeSo9BRxEdtTEEhiP/3wv2gH5PkoN9JvhJVFrU2t8ChtdjmiILoEY/XQ+EYeWz26CbYDVY07ps9zw0p6vSd8a3kAC06OKqtcOuVMefN2kVMl3+Y3+o4snT/6XR7uKFEYHbm6LAkOvdhunyaqI4i6cozowKIGjpnlJN+fjoNArwwNDiEIMA35ctJKZREhglDhdZ+fWiWw80kfXAyHcnVcu0qByXXci9MJfQAyOb1lCU/89xKdoOC7/9X373WCn9UcVoG9Li5/68rTfZ6Ogib1khBGEsVRiLXuPzwt3GqD4thHgD+C7gRSHE7wPEcfwl4J8BfwT8HvALcRzPDgE/LNQ2EKHLijbA7+/SxeHcypjivXYKLfSo0yfs79Kjsj8KETIRhB28Xof+JCd8gEqTFa3Pza6HCAaKwJhesNQZ4CnTPtPOi8BQEY62myYJmJUxSoMEpoMe9IEYzxsQiJxaWdLzV6mpFJI49AiKiCycB84qInRp6D6B25GtGOOuuaZBpcWa1qOrFCwT40gB7DoVRQAFvosb52RkqMYMcLHiMlAKIMsZ0/YCyldFXu/AqhiU0QAAIABJREFU7dGLprW9KJWE4TMYJDv+Oe1C6yboNi19wE7XRUSBKmxzJq0ap1mPbtFEFq2ttfX9x6gWkgtmm6gv1TeN1hgCQykw7nP6eD15nFMfp8CQ73HW6jJQRrDGJEKp0qKizHQDt0d3qifOMBXGVS1luRGaAM4qK6KDRYCIQ3qTWkiUWmND7+OqeVFxJhAYag1bM1z6mVa13HY/nVVqobwWfr8z2QMjo37rdpJxTFG/CQFmlYYufXlEVJACw5DfOxU8At8jQsNaBHFb4kSjaAn/QaCJjAIj5wft1ANjyUw8D4JlbCHJpl5USqPNIwFdE0t1j4yqeBZPYMyL1Lg4jApde3XBMIVkia7rNNxtCsnvxHF8Po5jO47jrTiOfzDzu+fiOL4/juO3xXH8ubsfao5QhcjlhovwunSocH51PIEBsCbaxF6XLhU29/bPQ7rjuqn3CNwuvdhmY1Kvnd2kQZ+dfkJgmDSnKDAA6qKXEhi5tW2oHckzlSGBYU1TYJhVBDE2PoHvqp34HL9orCpVXBUR6eXXqnBQKDLg/ppH5HboxvbkKCRnhZbo4avd8IlRkgB2AyuUhVPoewyiHP0e1JjPOy5eXxbM1Vpz/LGVJnaQFMx9evEU1UjGXDXrwZLbdbfrNDSPXmpQm5O/RhaN07TCmzSEvEbr62N8duw6mDW29F2qcZdubLO1MoYAUsTEhUqfeLBLH5tTzTGFu90AzWDL7KUKhco4HxUAu5ma6QaDLoN4CqGUKjAGeIkia9o9e1BUV2lEuzhIT4beFONRkPPNd3v4GDQmRb+aDgidFX30Ouc29ysr2MqzJva6k1NINA3sBi1tkCrOZhIpVpWG5tHtu4g4wo9zSl3KwpTruYOH7/uE6Ps9VUqUKBjZB/5FP9zqmiguhSSbdnFMHuL3IimCFn0dD4Ls/KuW61+JO4A5EqO6RHM/09ZW5C2bpJBEUXFRrYeN5aGp8kRd7rherg9w4h7d2OH86phCpCaJjktODz3o0Y0rnGmNIzCSCMIBodulG1nje8cBKk1qcVfuchKr5I/ZBUvgyaKikpsCQ+6inrZ9fFcRGNMUGJlITd+TBIaT506hWcPBTU08vbwiWg8KRUbdU3UJBrKYHdtCAtK/gA420nxvMM0Dw6pjBgmB4TKI9Nw9MM7Zffy+JCdqjQkEht3E8BMCozt9zLoBRoWW5g4VGLGZ3y60VaMhBgRezuqOLBpncAbXUwXGAxfGhiFB/RRr8TYtuuxQ49KpMfeCWg/OGh3CQZt27HB2nHJLCKius2V0cZPrUZ3Qv5wxxAy9Pn3s2QoMBilpZuW1HoA0Iw53qSHJqlktJGdsj8Dr42GNjw8GFSFcp6UNUr+MqekfdzBmU3nWCL9PL7ZZmRQLbDdpaX0GGQKjbk9p1zCr1DSP3mAYYV2EiSeALTyCwCcU2oicukSJw4CZeXJedOE7QmDk/KCdPd9xeYjfi1SBsURFXBZlUkiJO4F+hFJIDoJsdHSRa68mpAdGeJJSSI4lFIHxSMulTp+BVmVznGJCFSz3On2cuE+PCmdaYwoW5UFw3h7g99v0mK7AcKIuFVX0TvdNkAXLuunhewOpesir6FUeGKctl9AbEKJRrUxxaFYP2lVcQt8jQKeeswKjEg8IoxhCnwA9X4JkXigy4ELFJXY7k+MvASorVKMOFWTvuiemyf+b6OEAnZDQl0kME5U3B0VlaMAYuh0CNFbqE8gou4kW9OQ4POnBMrZFJoFVp6m7aauAn1dspzp3lQE2AZBzYZugcRrR/hbffVZngMkT77ww/rj6Fo3gtkyKiWtc2hijmDAdMGucMrpYYZdOXBlPYABU11kTHSJXFsvV+mQCQ0Q+Nr4yVbUmE2aWPMeG6aZJQHYlRwWGs4bt7+IIlYqhOSPS3uFxCfnZT8c8UXmkxt3QBukc8mKDxjTi4EBjXkX3u5gEGGGfPhYbjcnkcYMeBPLvG8TWdDWRJUnVvpsQGHoBLSRDBUboe6UCo8RCMNpCstjC19AEbkJg5FyEjygwlrTAn4Xk+i2aiLpTLMS8vcTSI7tumUu0CZBta8vb8ycLTYMo5lilkCzPVc4TKnXgSvUWlggx6+vje71Uq8kDToeK8BmICutjXfmHEYSx16VHhfVxZp8AlRZ2ONy1d6cVkKpgOWX5hAmBkZv0WsrA140BsS/jNCcqQSB15XeES+S7uHn7FZhVrFgWCqh+84UoMBQZdcbqYccDerE9XnUD4KxQCdrptRRmZXLPoD00YAxVC05uxbpZAbPKKaNH7PXoxTbr9QljVsRVjb6K7TQnt8gAWDXqwsXNFHG5jduq4cR9LEUAuXklamTROAOhy/es3sZqbo0nIAFqp3D8m6wIqcC4emFlwnHrbGptGaVKdbx3DoCzRjNu46i50WhMaCFR92GTrmwpi63JhJmaQ6fsgMBzCdGoVfJVYOiD21RVC4lTbYw3PssQZrE/YBAbk9teAOwGdfp4g5yTUyAlU1ZFGwuPAfb4RCk1jmrcSwlHX0zxwAAwq7KdJvDUuItQYGQ8MALZQlIqMEocNowjZOKpa1qqwCjKAwOOsQJDFUHmEpl4ZrGQ574SSw/rCJGwB0Gy3oZRscqIpIUE5jcYPepYzhXublHdAARv078BwA9ee/v445QC4+2VmwDoTmP8hc880FcZqAJy8i6g6bepCPlQ7At7aowqwLrpEwVuvh4BygNj3eirOFdzsvEopH4ILV2OJdcUDVAxrQMgRouCfL0WDgLVQrJl9qkxoIvD6UkERqWF6e9iC1kQGdYEI0MYMWSNApm4kZuSAVIDRgdXEmiT5p/yVdmyXLRQFcxTCYw6NTE0kQ2ElV+BZdWx4z6WkAoML86RoEvQOA2A+NaraPUx/hcJ6ltones8shFz+eK5yYVqdYN1rU1D9GnHDm8/M0FZUV2jFm7jCBc3Njg9zlMDUgLjXMXDiKQnzsTrYQ0VWQmhmWsUYHUNMdjmrCPns1Of5KMix7ymDwi9AYNpPioAdp0qfbRIrnmxbudnsqXI48uOiqtlgvEopOq3hHA0bWe6M71ShZlI/+mgCFJVERgOLmEglWelAqPEYSOrwFj07pxUYMh7rvTAODgSkmbRRNSdoiQwStwJsrWZtUSbAFnjzqJjVP2wmNa8RWF5rnKe0A2obaC99RoAZ8+cGX+c6YBV55IhCYxLZ7cmn89ucUrvUsWlS4WLaxOK2UoLzRvuzOp2dfJDdBpj6SnSIMcCz6zIFAitjxl79LFYm7TzC6kCY93yiXxPFpt5yqmtKmbYRydCEBPEi20hWdc61MSAblzh9DjjVoDKCrq3m7YDOdUpHiKpIWsfEbr4cY4KDDXuRjwc81hPF0iJq3OOjxm5soVkGnFl16nGfUSo5qtp5xdHZtWwwqECI1dyJEFD3du730hNeceivgn9W1T9bVbXNycfV13H8W+zaQ5wGquT1SvVNWxvmwoeAywuTFwPJPl5zvGwY1cW4JMUWWoOrRkeUTDIN80D5NyPIx6wpadErbE6/jhNB7vJitbFwsPF4tQk1YMatxP1sdV11nNNTpGf39sqMtYWqzb5wb3SxAo6Q8LRnkI4AphV7HiQEmw+BSQjqRSSuh4Qhj5BXCowShw+khhVIRa/O6dnWkjyduUf8cBY0gJ/FhJiZtlaZB7clAR96YFR4m6xjB4YkH/LXBZCCPzweCkwTu5KUT8NN/5E/lyZIBcHqG2w6iqlxnfcP/m46iqbRo9QDOhH9pSit4WIQ9aFLBIMe5pxplzQVwyXuJ8zgQFQadKkJ4useAaBoRQY61ZI4LtE6PkqJMwaetjHJCkWFtRCotox1kRHKTAqkz9zZwURDFjRpDlhbVLSBKTF57rpISJf7Z7n5AMA4KzSdNtU8elhTyHQkvQZn8rAZ8CUlBUAq0Ylfist4gxrSqF6UFh1jKCbFraaVck/q10pMIC0JWwslC8O7TdThcFY1DYQ1/+YC9WIi/ffO/m46nrajjHA4v5T0xUYZ+0Blb5Pf5oixkpibT2ivmzjypcEU14+2lsAnNkcEzmbjnuFJl128BhgTvadAKm0if5jShzoZo4ERkWSLG+r7kIPnEnpOwB2EzPopISj7UxZewHMKmY0SNckL845OhpSBcaK6RMFAQEadqnAODT4vs8bb7yRpiydRFQqFRxDrrvWEXjwN3RBe1CMAiNLiBxXBUay+7xsCoxPfeh72O0HS7V7XuJoYpkIjOw6VKgCQzBUYCzZ2jAJJ5jA2IRvvyp/dibsNILctb3+xwAY1SnHOausaV26uDj11hQvBPmAfZ/dhhgsZ0rRqwqWlu4q40czX+NMWyai2GoXdR4FxorpE/Zd/DyjENX5taCPlSUwFtFCAuCscdbuo4sBD90zQZ0DafF5j9WGCJqTfA4gJTA2bR/dkykree+eV7qvUUOjR4WHxqVoQDr/tswBtvDxhDXdTNSqYcdfT4s4w8yRwLDraEEvVWDkmqiRoHl2+PPqPZOPq2VUF9UphXt1HXo3EZqekkFj4awh4pDvWOni9mo8dHqyiSfABUMqCIRVnfzla1igmTT1AW1/kH8bkvJ/ec9aF7rw2OWLk4+ttKjHXWzh48YWpyZ5roCKEO6k97aRa3KKJJ8vWdvyXye1vQBUmuhee34CQ6nCDNVCEgkz/4drRWC0jJAoVARG+QB/aHjjjTdoNBrce++9+ZOnS4A4jrl58yaPrsq0pKNQPOqawPXlPZc3yaAfIa+PomAbunpd/LU8CKpWAQRxiROJZWpDyq5DRSojNCEIyhaSY4J6ph2kNmVntroBnvxyn0p0OKuY3jYt3eO9j9w7+ThVsDzgyHO2mhMKG1Axlg5NzUWEnjK/y1OB0UoTUQaYMxQYksBYNXziwMOPc1ZImFUEMXWStAt9cV9mzipm5000Yr7r7fdOPi6Jk9Rk8bTanFI8KTJqw/QwCPL1MwFwVhH92zyyafDg+dOTi+CkYDaHCqDpPgB1rHBIMhh5yv+tGsLrUtVkYWvPkvTfCQw7NcNl/YHJx9UzBEZjCmlV24CgL9eEaUoNRYJctm5x4fTWZM8HRYLcW5HrgT2tDQnArqfrgRubuat4AC6ZtwB48PzpKceuUAnb2Pi4mGy1preQGEFvxHsiN6gxP6haSN5zeULKjBqHCF2aQiqmqrM+a6UKS4gXYU5ZH+8UKoWkaQTEqoWk9MA4PAwGA9bX108keQFSVry+vk7dkNLio7BzOZJCkrsC4/h7YFRMTb2W60iJk4llIjAOa03SMvHUx6WFZPHfVotCdme2NqXnPUtuOFNaTZw16FxHRD6V2pTCRhU951UBudaack5QKRBSxuyhTzfLOygqTeygQ0XIFpLzq1MKC+XH0dQ9NNUCkWsBrs7fEjJ20scYH+F4GKiuwvZ/BEBYU4ocNR+2hCyeLm6uTT42aSExPCwCmeaRt39B/zY1+qytTiHaFOlyj/I5SHaAJ8KqYwS9tIjLVSVh1RGhyylbERhOjoVtFt/3N6SS6r7vm3zMvARGtg3FnkJYJSqO219D2FNIymQ90OUcmmoEC2A1qDPAUiRYo4AWEra/rt5rytyvtKgEu9j4DGZ5YFh1NL+TtgrlOocqLUDQ8r4NwKP3n5t8rK3IO0safq62pqzTkKrCEvWRZhRAYChiuGH4RGGAH5cKjMPGSSUvEgghSD6Co/BJ6JpGoNzy8yYwsskjuRkJHzEkxEXFWJ4irkSJPLFMSp5RY+Hi1iRdCPwkheQoLPQ54Hiu4PNgM5M8Mm3SjBAY0xUY7Lwhf5764K9M52pyF/DKvROMQRPYdWpIo0NvWkLBnaDSwgzaqdHgVmNKYaEetJu6j0mgPCryTSGBIYGBZi5O4umswo4q4qYWn3I+XF2VqpH3XJ5S+KYGjANMERKKvIvPVQg96N6YMf+UiacqmFdXZhNoemEEhhznGVPeC5VKAQoMgO95Bv7aazAthSRLWqzdN/m47HowzRRUtWMQh9NbTYwK6BYXTHk9fmCaegvSRA+pfDCmq6YOimR92/m6vB+1KQ/Azgqm12bDDrnv9IwdbLuOiKP03q5Wp7RaHRRJK8+O9ClK1pGxUNdhUxGOm2szCAyzhgg9HCFjZc081Ufpe8hz1jWfUMWoljunJQ4fiYnn4p9si9yRzJ7vKPh9FIGEAC3SELBEiaOMZVJgCCHSWscs8J7VdXHsPDCO5wo+D869S74+8OT047JFylTJ+Bog2a15Csh71C7gI/dNKXoBrAaOcsL3YmN61OlBYTfR3V02nZgzG6vTZUVK6tzQXbX7q+fr4aB2njdNaaamF7HbOS+cNYhkwZ60foyFmg8rgTQ9bEzrv08iMDXZKmDkbViZFJ+D7elj1k0wq5wWsu3lh981xZgWUpVEUsTVajNk9weBGueWKQvbep7n3otZzLZhwzt+FFbvk/9MQtYfozGFfKxm1DjTlBpCSCKxJxUEl85MIUUArDpOPCQ0N6YpHw4KZwUQkgibNodAErGDbU7ZAW+7OKXVBFLybhW55rXqOV9nZxXa35Q/T1t71XW4siJbWR65d8a4E38KRbzYRXi0JCkkmk9YemCcSOi6ztWrV3n44Yd59NFHef7554ki+aD58ssv88wzz9zxuf/5P//nPPzww2iaxssvvzzxuOSr6Cg814648uetwNCGapNlS+mYFwkBejz/uhIlZmOZCAwYrnNFqsJ0IfCTFpIjQFTngeXR2eSNtfvgZ/4lrF2aflyWwJi6I7k6/ue9SEiQ9rfk60wJf42KKwuWXar57rhWWuDuslXbYOvClDYakAWgWaUmvFSBketYVMrJptmHAMwiioV5MVJ8TlFgJC1FO9+YvWNtWKDbbCQERp5mmDA656YVcSCTcDpy/jUaU4rrzLlWkONu1nJUSSRtSZFsZ9lYmTGWovGf/y+SuJpGdrTOD3+uTyEwnDnnEMj7cN71wK7juLexRMAgNtmo53gParocy2Ab7DkIDL8nP69ZZIfyIFkTksBoFkFg3P6aeq9phKOcXw/Ve3ALLp2eYtYK+0hV2y6AVNU00C1qmk8USgWGbZYExkmC4zi88sorAFy/fp2f/MmfZGdnh49+9KNcu3aNa9eu3fG53/nOd/Lbv/3b/NzP/dzU45LHWaUwXiiMgiXVuhAEcVyoXHuRKAnQEicVFVNj4Ec4S0ZgGJrAo1gPDF0TeMdMgXFyCQyA83M8GEwz+MwiW7BMIzCS3dgDFCx2/3ra8553Cwl+D9x2qrCYCrNKDRdTBPiRke9YVLFwypAEhmUtUoGRuX7Trn9CRoUuVGbsnAPYdU7pkgjw8r71qnPOP5Bz8ADzD2BVKAIjz+JTFZunlQLj/MaMdpaioRvyn2nItppMU2oobwaIpyswkmNvfln+PK0FAsCqU4m+gYXPDjXW81RggJw7g+3pkbMwJO9CbzZhpubQpqaIqtUZrRsHRTYGexrxoogk0bkOuj1blZOQqmpNcioFebQYDlXNx49DAqFRW6L+3eOEj376S/zRN3dzPec7zjb5W3/24bmP39zc5IUXXuCxxx7j2Wef5aWXXuITn/gEn/nMZ3j22Wd5/fXXefPNN3nttdd4/vnn+cIXvsDnPvc5zp07x6c//WlMc1Sh+fa3v33CO40iUQOGSvmxSIwoMApQSRi6IIhiLON4PMTvRRLDfBTagUqUOEz8X7/wPfzjf/U1Nqe1wx9BDFtIClRgaAI/VN5Cx2RtKKnaWTj/mEwveOq/n37cvAoMsyIfnj25GzmTOLDqVKK+Uj3k3B+dFOD927MLWQCriiPclEzJleVUxcKaLv0kConUnBdZMmpapKZupuOeuQsNYDdYVbvQbzs3Y/f3oMjOuWljBnndu9flzzMLZvn3Ja0v69NScw4KVWw+siYj8959+ey0o48GhIAf+4fw1N+VqpppxyUtZfUZ6qZsa9pMQqmB7nepGxG1ajV/Jj0hwmYRt1nSYCaBIefM5YZsQ3rbuRmfx0GRzH3dmj6fEyKpcz31npiKZO6rNalSFIFhVqgIH0NEhOhLJ38tkS8uXbpEFEVcv3593+++8pWv8OKLL/KpT32KD3zgAzzxxBO8+uqrOI7Diy++eMfvmSwjQbh4CUa2taOIB+3E++K4KzBq5TpS4oThodNNPv7jjyydwsBIW0gKVGBk1tLjkkJSbvXMgt2AD708bBKdhOwOeHVKGgUMC0jDmX1eu47ud2mZEfeuzjjvQZHdGZ5LgVGjoXkIgvwVBEqBsaolho4LJDBWMlGMs8gAZwX87nwEhtWg5t8G4PGHL97FAMeNI0ugzTH/EsyRQgJwb82DPlw6PUPdcRCoAtHxpR9HISaJReCRP3ew46e1msDo9ZhFBlh18Nrc01rnwpkZ570TNM/BN/7tfGtYgjlUIwCXqn2ivsnFUzmSYDCc+87a9PU0GbPXhvoM/wtI16QV5YHRyLN9KgvToYKHR4gb5xyVXWJuHEQpUTTieDyR8NRTT2GaJleuXCEMQ97//vcDcOXKFb72ta/d8fsld41/JBQYWubnAggMVeAfVw+M739okz/76Fn+wrtzfsYoUaJEIUjWvEJTSLLE8DHhbo/Jn1Ew5tkFyO6yzluwTEsnSGDVweuw4cCVi3O0KRwEBylCQEa6ai4mASuNnB/m1fuv65LAqBcVqTkP1h8c/qzPME1NdqJnFZ4gybCO3FUz7Zw/v2wU8LR0DDhg8Sn/rre3AiJhcPl0jj4VCYHWvSFf9ZzbIRYN5f0w4psxDtnrUZnRRmPXwe2ghx6mVcA9sqIeehsz1DDZSOlZ5J26znrvLbR5iNKDIhnLtJhrGPUimUuBIf+uhvJ/2WjlmJ6ShSEJDINSgVECvvrVr6LrOpub+5VKti3XSE3TME0zbRPQNI0gCO74PZPzHAVVQpEpJDCUaRcp114kGhWTv/cXvoNHLyy4JbNEiRJzwTiMFJKsAqNsISkxgtYFWQw2z003c4QhcTGrNx5SAoNgIJMS8kSWQJmLTKlhhn0cPeKJd8woyg4KVSi3hCIwitrtnAeN07J16Npfnn1sUnzOMj1Mjunfkj/P07JzEGS9G6bFgMLotZ654y9/b3vbaIadb19t8tl13wLNnO1JsGz4gV+FrSuwNWNnd4TAmGWqWpfRrO6ubJnIG5d/UJ73gfdOP26khWTGvZrcG90b+a9hMPQlicLpx6kEHmA+xZQ69lLNB+Dy2ZwVcOn7VLDwMAgI0EsFxgnGjRs3+OAHP8iHPvShQ/UwSN4qV1PgO0TRHhhDAuN4PMSXKFFiuXEoKSQFpjstCuWTUl4QAv7S74E2x0eaKjDmMLOz6xBHMNjJv2DJvv+spITkmO4NtMhnJe8kAVUsnLZkn/x7HphD4l0UhIC//Pn5lDfJru+8n1+CIgq5H/uf4c1/dzD5/6wd/0RF0L81W41yUCSfh9eZr6BcNrzn5+Q/s5AQmUKf/Rknn5m7O1/b10Fx3/fCL39jur8HjKodZpnGZq9t3sQdwOkr8nVzDsNCuyGNi+e5XxV5d8aWKSQPnsnZtyaB4WD5rlJgaKUC44Sh3+9z9epVfN/HMAx++qd/mg9/+MO5nPt3fud3+MVf/EVu3LjBD/3QD3H16lV+//d/f99xyY7cX/neGalsh4CiFRhJ68hRUJuUKFGiRLImmQWnkKQ/HxMFRklg5Ikzj8533EEIjOzDf94ERlYBMpcapCYNPyH/YtZ0AEE1knLt8+sLjtSc9wZPCIDaHMaE2WtpFFDIPfJfyH9mYaSFZJaJrCKq+rdnt0YdFIYt20ZCtxhCZ1mQEADxDAUB7JlDBe2WznPe7ByalVhi1UgTWYq4zucfgyf+G3jnj80+1m5C59vzq98Aka55BX1dmhXM7k10QqnAKFNIThTCcPJ9//jjj/P4448D8Oyzz478rtPppD/v/V2Cp59+mqeffnrmGHRN8NW//WeOhLlb9kHbKmBHMiFrSgVGiRIljgJSY+EiW0gy6+pRWOfzQPmktAgk/eWzerZhT8GSdwvJARUYIwRGzsWTEOr828WcvygkBMAs3wk4eA9+UZhl8plFtsWkiGtSacrWgnk8RI4rVu+d/1i7YBJsXmTXollGt0LIue/uFjNmTYfv+8h8x6bte/Osd6rdpKg1L4HhYEQuOhEBOvVK+bVc4vBxVB5qkxYPIYqVOh9XD4wSJUosF4bGwofTQlKEsm0RKFfwRSAxytPmUDHYBcqvsw/x86pBAimnLmQn1azCICEwluQhPinemmdmHzvSQrLA4nP1nvmPLZrASHbCj2MLybzYuCxfL37X7GOzn9Ms74nDwjzkXTLuRSttkvk2j+ePIVVhwzWpIALDrGCEAwylwCgLqxInGYkywtK1QnxAkjMWWSyUKFGixLxICIxCW0gya2npgVHiznH2O+Trg0/OPnakfzzngiVrNtqckTqwdyx5t5CALMi619X5l0SB8V2/AEKDd/zo7GNHruUCFRjJjn/rwtTDADlHzKr0DSiiYE4KyZOswFi5AD/692UrxCxkSbBFf2Y//o+lN8o8veR2A9oU44FxECRpUbNUIyD/LrMqY5KFNtuc+U5hOOiRiy4iwqgsqkqcbCQP80W0jwCEKqK2Ypb3WokSJRaPYQvJYSkwjsfaVxIYi8DF98Bf/9OD7VxC/gQGwLl3wTf+7ZwtEAWPxcwUZPOoU44CnFV44r+e79ijosBYuQe+56/C/T8w3/FWTRIYRVzz5DNZdDG+aFz9yfmOy35O5oI/s3k8JxLYR0SBkRAXs3w7Elg1SWAUGfFrVtDCAQZQsU+wF0yJEoClS6LQNIp5yPbDCKD0milRosSRQKrAOCwC45j4/5Qr+KJQn8P0EUZJgyJ2wJ9+AXo359tdHCmeCijAs3/fogudIlD0tZwXQsCTvzb/8VZN+lQUcc3LFpKDYaSFZIlIn2Tci77ODz8Nf/S7cP/3z3e8VYUuxSqmjAoEeAZ5AAAT4UlEQVTCH7BRrfHk5TmUcCVKHGOYxrCFpAj4gVRglHHFJUqUOApIPCkcs7gEsuPogVGu4EcdIwqMAgqWjQeAB+5gLEUoMDLnXLTUvAhkkw+K+PyKQnLdi5h/iffKMhXji8RRIcEOikRpM4/3RJG48G748JfmPz717ihwPTIdCPoYho1RKjBKnHDYBTvyxygCo4wrLlGixBFAKJckHOuwFBjHo4XkePwVxxlHqWAZSUQpYEcyLWLF8nhgHATZz2+ZcphTAqOAIi6R9B8kGeUkw8p6YCyRaiUhMOaJLz1KSIjGIgnVZC31e6CVewonDbquc/XqVR5++GEeffRRnn/+eaJItjm8/PLLPPPMM3d87o985CM89NBDPPLIIzz99NNsb2/nNezCkMiotYK+IxPlhVMSGCVKlDgCiCLJYDgFtrVlTTyPiwKjJDCOOopWPRwEIy0kBSowTGe5Cvx5MU9041FEct2LKOIap+WrKJeiuZBN55nHt+aoICnSl43AKHLuJ0jWvdAr74MTCMdxeOWVV/jSl77E5z//eT772c/y0Y9+FIBr167x67/+63d87ieffJI//MM/5Itf/CKXL1/mYx/7WF7DLgxWQd4XCRqKwFA1Q4kSJUosFIEirA+thaT0wChxKMimfczjnF8kDssDowh1x1HAshMYRez43/d9cl4/PEeKS4lR1OY0ojwK8PvytbpkSptk7he5JmX9NY6j8mxZ8Lm/Cd96Nd9znr4CT/2duQ/f3NzkhRde4LHHHuPZZ5/lpZde4hOf+ASf+cxnePbZZ3n99dd58803ee2113j++ef5whe+wOc+9znOnTvHpz/9aUxz1Pz6fe97X/rzd37nd/Jbv/Vbuf1pRaHoGOG/9r638TP/5GUeOLVECrYSJUocWyj+ovTAOCDK7Z5lwqILlmwBXoSpnXkIu52LROs81E/Dtb+86JEcDEnxVkTxefqd8JGvSG+CEvPhu5+Bs//J0D9kGXDpcfm6et8iR3FwHIYCI+uvURIYJx6XLl0iiiKuX7++73df+cpXePHFF/nUpz7FBz7wAZ544gleffVVHMfhxRdfnHref/SP/hFPPfVUUcPODUUrML738ile+++eolVdkqSzEiVKHGska16RyogsgaGXMaolDg0PvBe+/AeLNzrM7sBXVgo4f6LAOKZGdpoOv/Cvl0+JkVyXojwXjmO7UJF43387pOyXBY/8edi4DOffteiRHAzmIajCsmSwURIYC8MBlBJFI47H9zc89dRTmKbJlStXCMOQ97///QBcuXKFr33taxPP99xzz2EYBj/1Uz9VxHBzRfIwX34tlChR4iTg8laDf/Xlt+gMgsLeo1Rg7IEQ4u8KIf69EOKLQojfEUKsZH73y0KILwsh/kQI8YN3P9QTjB/9+/DMK4sexagCpIjd36RYOM594M7KfJG1RwnnH5Ovq/csdhwlhlg2Bl3Tlo+8gCFpXGR6SqnAKJHBV7/6VXRdZ3Nzf9S6rVJqNE3DNE2EqvI1TSMIxj/8/uZv/iaf+cxn+OQnP5kef5RhKwKjqBjVEiVKlDhK+Gvvu8wz3/8AP/TImcLeI9uaV3pgSHwe+OU4jgMhxMeBXwZ+SQjxDuAngIeBs8AfCCEux3Ec3uX7nUzU9z/ILARZP44iivBsCkmJo4NH/jw0z0m/ihIlThIS0lYrUG5eemCUULhx4wYf/OAH+dCHPpQL2fB7v/d7fPzjH+ell16iWl2O2OWVqrwHwgkqlBIlSpQ4TqjZBh9+39sKfQ9Tzyowjgc5fFcERhzH/yLzr18Aflz9/CPAP43j2AVeF0J8GXg38P/ezfuVOAJ47K9A5Bdz7qS1YtkUCscdugn3P7HoUZQocfioq5Qcv1vce4woMMq+/JOGfr/P1atX8X0fwzD46Z/+aT784Q/ncu4PfehDuK7Lk08+CUgjz3/wD/5BLucuCus1SWD44ZK1yZUoUaLEEUVW0XZcWkjy9MD4S8D/qX4+hyQ0Eryh/ts+CCF+FvhZgIsXL+Y4nBKF4Ic+Udy5m2flq9sp7j1KlChRYl6sXZKvD7y3uPcoFRgnGmE4WZj6+OOP8/jjjwPw7LPPjvyu0xl+T+79XYIvf/nLdzu8Q8eKMtcMwlKBUaJEiRJ5INtCop+UFhIhxB8Ap8f86lfiOP6UOuZXgAD4ZPK/jTl+7LdRHMcvAC8AXLt2rfzGOslYUR4Ll8pWhRIlShwBXHg3/Py/hlMFyjtLD4wSJVKcblb4rkvr/OL3P7DooZQoUaLEsYCZSXcyT0oLSRzHU7eehBB/Efhh4AfioXX2G8CFzGHngW/e6SBLnBCsXYKn/ye4//sXPZISJUqUkFEImw8V+x6lAqNEiRSGrvF//Ox3LnoYJUqUKHFskG0h0Y9JC8ndppC8H/gl4D+L47iX+dXvAj8hhLCFEPcBDwL/5m7eq8QJgBDw6E8cHdPSEiVKlCgapQKjRIkSJUqUKFEQLOP4xajerQfGbwA28HnlmP2FOI4/GMfxl4QQ/wz4I2RryS+UCSQlSpQoUaLEHpQKjBIlSpQoUaJEQch6YGglgQFxHE9sUozj+Dngubs5f4kSJUqUKHGsUaaQlChRokSJEiUKQpbAOC44fn9RiRIlSpQosSzQM/sIhr24cZQoUaJEiRIljh1KAqNEiRIlSpQoUQys+qJHUOKQoes6V69e5eGHH+bRRx/l+eefJ4oiAF5++WWeeeaZOz73r/7qr/LII49w9epV3ve+9/HNb5Ze6iVKlChx0mCVBEaJEiVKlChRohBYtUWPoMQhw3EcXnnlFb70pS/x+c9/ns9+9rN89KMfBeDatWv8+q//+h2f+yMf+Qhf/OIXeeWVV/jhH/5hfu3Xfi2vYZcoUaJEiSWBaRwP34ss7tbEs0SJEiVKlCiRB+zGokdwYvHxf/Nx/v2tf5/rOR9ae4hfevcvzX385uYmL7zwAo899hjPPvssL730Ep/4xCf4zGc+w7PPPsvrr7/Om2++yWuvvcbzzz/PF77wBT73uc9x7tw5Pv3pT2Oaox4qzWYz/bnb7aLM1kuUKFGixAlC1Tp+5X6pwChRokSJEiWOAsoWkhOPS5cuEUUR169f3/e7r3zlK7z44ot86lOf4gMf+ABPPPEEr776Ko7j8OKLL44936/8yq9w4cIFPvnJT5YKjBIlSpQ4gWg5x88g/PhRMiVKlChRosQy4dy74Bv/djRStcSh4iBKiaIRx/HY//7UU09hmiZXrlwhDEPe//73A3DlyhW+9rWvjf1/nnvuOZ577jk+9rGP8Ru/8Rtpe0qJEiVKlDhZ0I9JhCqUCowSJUqUKFFisfip34K/+u8WPYqFQwixJoT4vBDiT9Xr6oTjLgoh/oUQ4o+FEH8khLj3cEdaHL761a+i6zqbm5v7fmfbMqVG0zRM8/9v735j7KrrPI6/P/1DBlFD+bNKGIvFkFA07KgT4kbdsAib1QcLm+w/2SXwwLAk1sWQTWzwgewmm5Bdddd9IkE0gUQXiEXtM0DinzW7gRaoFmmwSooWKpSyRJs0AvL1wZzWaXvn9rQzt+fcO+9XcjPnnHvuud/55pd7vvOd8zt39aEpIStWrOC1114betyrr76aTZs2LX3AkqTee/jmD/HIzR/qOowlYwNDkqQuveEMWPP2rqPog43AQ1V1AfBQsz7IXcC/V9V64BLg6PkWY2jv3r3ccMMNbNiwYUnuV7Fz585Dy5s3b+bCCy9c9DElSePnLW+e4sw3Ts5XtTuFRJIk9cGVwKXN8p3Ad4HD5nYkuQhYVVUPAlTV/pMY35I7cOAAMzMzvPrqq6xatYprrrmGm266aUmOvXHjRp566ilWrFjBeeedx2233bYkx5UkqUtZaK5lF2ZnZ2vr1q1dhyFJklpI8mhVzS7RsV6uqtPnrf9/Va05Yp+rgI8BrwDrgG8DG6vqtwOOdz1wPcDatWvf+8wzzxz2/I4dO1i/fv1ShD7WzIMkqY8WqjG8AkOSJJ0USb4NvHXAU59ueYhVwAeBdwM/B+4BrgO+fOSOVXU7cDvM/YPkBMKVJEk9YwNDkiSdFFV1+ULPJXk+yTlVtSfJOQy+t8Vu4PGqerp5zTeB9zGggSFJkiaPN/GUJEl9sBm4tlm+FvjWgH22AGuSnN2sXwY8eaJv2KdptF1Y7r+/JGn82MCQJEl9cCtwRZKdwBXNOklmk9wB0Nzr4p+Ah5JsBwJ86UTebGpqin379i3bP+Krin379jE1NdV1KJIkteYUEkmS1Lmq2gcc9UX1VbWVuRt3Hlx/ELh4se83PT3N7t272bt372IPNbampqaYnp7uOgxJklqzgSFJkpad1atXs27duq7DkCRJx8EpJJIkSZIkqfdsYEiSJEmSpN6zgSFJkiRJknovfbr7dpK9wDMjOvxZwIsjOvakMVftmKf2zFV75qo9c9XeqHJ1XlWdfezdumV90Rvmqj1z1Z65as9ctWeu2hllngbWGL1qYIxSkq1VNdt1HOPAXLVjntozV+2Zq/bMVXvmanTMbXvmqj1z1Z65as9ctWeu2ukiT04hkSRJkiRJvWcDQ5IkSZIk9d5yamDc3nUAY8RctWOe2jNX7Zmr9sxVe+ZqdMxte+aqPXPVnrlqz1y1Z67aOel5Wjb3wJAkSZIkSeNrOV2BIUmSJEmSxpQNDEmSJEmS1HsT38BI8mdJnkry0yQbu46nz5LsSrI9ybYkW7uOp0+SfCXJC0memLftjCQPJtnZ/FzTZYx9sUCubknybDO2tiX5SJcx9kWStyX5TpIdSX6c5MZmu2NrniF5clwdIclUkkeS/LDJ1T8329clebgZU/ckOaXrWMed9UV71hfDWWO0Y33RnvVFe9YY7fWlxpjoe2AkWQn8BLgC2A1sAT5aVU92GlhPJdkFzFbVi13H0jdJ/hjYD9xVVe9qtv0b8FJV3doUr2uq6lNdxtkHC+TqFmB/VX22y9j6Jsk5wDlV9ViSNwGPAlcB1+HYOmRInv4ax9VhkgQ4rar2J1kN/AC4EbgJuK+q7k5yG/DDqvpil7GOM+uL42N9MZw1RjvWF+1ZX7RnjdFeX2qMSb8C4xLgp1X1dFW9AtwNXNlxTBpDVfV94KUjNl8J3Nks38nch92yt0CuNEBV7amqx5rlXwM7gHNxbB1mSJ50hJqzv1ld3TwKuAz4erN92Y+pJWB9oSVjjdGO9UV71hftWWO015caY9IbGOcCv5i3vhsH5DAFPJDk0STXdx3MGHhLVe2BuQ8/4A86jqfvNiT5UXMJ6LK/ZPFISd4OvBt4GMfWgo7IEziujpJkZZJtwAvAg8DPgJer6rVmF8+Fi2d9cXysL46f54H2PA8MYX3RnjXGsfWhxpj0BkYGbJvcOTOL9/6qeg/wYeDjzaV60lL4IvAOYAbYA3yu23D6JckbgU3AJ6vqV13H01cD8uS4GqCqfltVM8A0c1cKrB+028mNauJYXxwf6wuNiueBIawv2rPGaKcPNcakNzB2A2+btz4NPNdRLL1XVc81P18AvsHcoNTCnm/mzR2cP/dCx/H0VlU933zgvQ58CcfWIc0cwk3AV6vqvmazY+sIg/LkuBquql4Gvgu8Dzg9yarmKc+Fi2d9cRysL06I54EWPA8szPqiPWuM49dljTHpDYwtwAXNnVFPAf4W2NxxTL2U5LTmxjUkOQ34U+CJ4a9a9jYD1zbL1wLf6jCWXjt4smz8BY4t4NDNkL4M7Kiqz897yrE1z0J5clwdLcnZSU5vlk8FLmduPu93gL9sdlv2Y2oJWF+0ZH1xwjwPtOB5YDDri/asMdrrS40x0d9CAtB85c1/AiuBr1TVv3YcUi8lOZ+5/4oArAK+Zq5+L8l/A5cCZwHPA58BvgncC6wFfg78VVUt+5tLLZCrS5m7BK+AXcA/HJyDuZwl+QDwP8B24PVm883Mzb10bDWG5OmjOK4Ok+Ri5m6gtZK5f1LcW1X/0nzG3w2cATwO/H1V/aa7SMef9UU71hfHZo3RjvVFe9YX7VljtNeXGmPiGxiSJEmSJGn8TfoUEkmSJEmSNAFsYEiSJEmSpN6zgSFJkiRJknrPBoYkSZIkSeo9GxiSJEmSJKn3bGBIkiRJkqTes4Eh6ShJzkyyrXn8Msmz89b/dwTvd12SvUnuGLLPqc37v5LkrKWOQZIkjZb1haTFWtV1AJL6p6r2ATMASW4B9lfVZ0f8tvdU1YYhMR0AZpLsGnEckiRpBKwvJC2WV2BIOi5J9jc/L03yvST3JvlJkluT/F2SR5JsT/KOZr+zk2xKsqV5vL/Fe7yzOc62JD9KcsGofy9JktQd6wtJbXgFhqTF+ENgPfAS8DRwR1VdkuRG4BPAJ4EvAP9RVT9Isha4v3nNMDcAX6iqryY5BVg5st9AkiT1jfWFpIFsYEhajC1VtQcgyc+AB5rt24E/aZYvBy5KcvA1b07ypqr69ZDj/h/w6STTwH1VtXPpQ5ckST1lfSFpIKeQSFqM38xbfn3e+uv8vkG6AvijqpppHuceo7igqr4G/DlwALg/yWVLHLckSeov6wtJA9nAkDRqDwCHbp6VZOZYL0hyPvB0Vf0XsBm4eHThSZKkMWR9IS1DNjAkjdo/ArPNzbKeZG7+6bH8DfBEkm3AhcBdowxQkiSNHesLaRlKVXUdg6RlLsl1wOywrzmbt++uZt8XRx2XJEkaX9YX0uTxCgxJfXAA+HCSOxbaIcmpzX9MVjM3B1aSJGkY6wtpwngFhiRJkiRJ6j2vwJAkSZIkSb1nA0OSJEmSJPWeDQxJkiRJktR7NjAkSZIkSVLv/Q7SeNj7HW3+JAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n", "\n", @@ -849,26 +823,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=3)]: Using backend LokyBackend with 3 concurrent workers.\n", - "[Parallel(n_jobs=3)]: Done 3 out of 3 | elapsed: 25.6s finished\n", - "[Parallel(n_jobs=3)]: Using backend LokyBackend with 3 concurrent workers.\n", - "[Parallel(n_jobs=3)]: Done 3 out of 3 | elapsed: 54.0s finished\n", - "[Parallel(n_jobs=3)]: Using backend LokyBackend with 3 concurrent workers.\n", - "[Parallel(n_jobs=3)]: Done 3 out of 3 | elapsed: 1.1min finished\n", - "[Parallel(n_jobs=3)]: Using backend LokyBackend with 3 concurrent workers.\n", - "[Parallel(n_jobs=3)]: Done 3 out of 3 | elapsed: 1.4min finished\n", - "[Parallel(n_jobs=3)]: Using backend LokyBackend with 3 concurrent workers.\n", - "[Parallel(n_jobs=3)]: Done 3 out of 3 | elapsed: 1.8min finished\n" - ] - } - ], + "outputs": [], "source": [ "from sklearn.model_selection import cross_val_score\n", "\n", @@ -890,22 +847,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f = plt.figure(figsize=(7, 5))\n", "plt.xlabel('Dimensionality of latent variables')\n", @@ -940,14 +884,11 @@ } ], "metadata": { - "nbsphinx": { - "execute": "never" - }, "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "inm-elephant", "language": "python", - "name": "python3" + "name": "inm-elephant" }, "language_info": { "codemirror_mode": { @@ -959,7 +900,10 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.10" + }, + "nbsphinx": { + "execute": "never" } }, "nbformat": 4, diff --git a/doc/tutorials/granger_causality.ipynb b/doc/tutorials/granger_causality.ipynb index 45e27e6bd..40aa4b4bb 100644 --- a/doc/tutorials/granger_causality.ipynb +++ b/doc/tutorials/granger_causality.ipynb @@ -213,7 +213,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -227,9 +227,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.10" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/doc/tutorials/parallel.ipynb b/doc/tutorials/parallel.ipynb index 2ab344d91..3cc9f8a35 100644 --- a/doc/tutorials/parallel.ipynb +++ b/doc/tutorials/parallel.ipynb @@ -278,7 +278,10 @@ "cell_type": "code", "execution_count": 9, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -393,7 +396,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -407,7 +410,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/doc/tutorials/statistics.ipynb b/doc/tutorials/statistics.ipynb index bb34720c1..5196e8860 100644 --- a/doc/tutorials/statistics.ipynb +++ b/doc/tutorials/statistics.ipynb @@ -545,7 +545,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -559,7 +559,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.10" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/doc/tutorials/unitary_event_analysis.ipynb b/doc/tutorials/unitary_event_analysis.ipynb index 16f503757..e3cce9873 100644 --- a/doc/tutorials/unitary_event_analysis.ipynb +++ b/doc/tutorials/unitary_event_analysis.ipynb @@ -50,6 +50,7 @@ "import neo\n", "\n", "import elephant.unitary_event_analysis as ue\n", + "from elephant.datasets import download_datasets\n", "\n", "# Fix random seed to guarantee fixed output\n", "random.seed(1224)" @@ -73,8 +74,9 @@ }, "outputs": [], "source": [ - "# Download trial data\n", - "!curl https://gin.g-node.org/INM-6/elephant-data/raw/master/tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix --output dataset-1.nix --location" + "# Download data\n", + "repo_path='tutorials/tutorial_unitary_event_analysis/data/dataset-1.nix'\n", + "filepath=download_datasets(repo_path)" ] }, { @@ -464,13 +466,13 @@ }, "outputs": [], "source": [ - "io = neo.io.NixIO(\"./dataset-1.nix\",'ro')\n", + "io = neo.io.NixIO(f\"{filepath}\",'ro')\n", "block = io.read_block()\n", "\n", "spiketrains = []\n", "# each segment contains a single trial\n", "for ind in range(len(block.segments)):\n", - " spiketrains.append (block.segments[ind].spiketrains)" + " spiketrains.append (block.segments[ind].spiketrains)\n" ] }, { @@ -501,9 +503,9 @@ ], "metadata": { "kernelspec": { - "display_name": "elephant_nixio", + "display_name": "inm-elephant", "language": "python", - "name": "elephant_nixio" + "name": "inm-elephant" }, "language_info": { "codemirror_mode": { @@ -515,7 +517,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.10" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/elephant/datasets.py b/elephant/datasets.py new file mode 100644 index 000000000..6483e5670 --- /dev/null +++ b/elephant/datasets.py @@ -0,0 +1,179 @@ +import hashlib +import tempfile +import warnings +import ssl + +from elephant import _get_version +from pathlib import Path +from urllib.request import urlretrieve, urlopen +from urllib.error import HTTPError, URLError +from zipfile import ZipFile +from os import environ, getenv + +from tqdm import tqdm + +ELEPHANT_TMP_DIR = Path(tempfile.gettempdir()) / "elephant" + + +class TqdmUpTo(tqdm): + """ + Provides `update_to(n)` which uses `tqdm.update(delta_n)`. + Original implementation: + https://github.com/tqdm/tqdm/blob/master/examples/tqdm_wget.py + """ + + def update_to(self, b=1, bsize=1, tsize=None): + """ + b : int, optional + Number of blocks transferred so far [default: 1]. + bsize : int, optional + Size of each block (in tqdm units) [default: 1]. + tsize : int, optional + Total size (in tqdm units). If [default: None] remains unchanged. + """ + if tsize is not None: + self.total = tsize + self.update(b * bsize - self.n) # will also set self.n = b * bsize + + +def calculate_md5(filepath, chunk_size=1024 * 1024): + md5 = hashlib.md5() + with open(filepath, 'rb') as f: + for chunk in iter(lambda: f.read(chunk_size), b''): + md5.update(chunk) + return md5.hexdigest() + + +def check_integrity(filepath, md5): + if not Path(filepath).exists() or md5 is None: + return False + return calculate_md5(filepath) == md5 + + +def download(url, filepath=None, checksum=None, verbose=True): + if filepath is None: + filename = url.split('/')[-1] + filepath = ELEPHANT_TMP_DIR / filename + filepath = Path(filepath) + if check_integrity(filepath, md5=checksum): + return filepath + folder = filepath.absolute().parent + folder.mkdir(exist_ok=True) + desc = f"Downloading {url} to '{filepath}'" + with TqdmUpTo(unit='B', unit_scale=True, unit_divisor=1024, miniters=1, + desc=desc, disable=not verbose) as t: + try: + urlretrieve(url, filename=filepath, reporthook=t.update_to) + except URLError: + urlretrieve(url, filename=filepath, reporthook=t.update_to, + data=ssl._create_unverified_context()) + + return filepath + + +def download_datasets(repo_path, filepath=None, checksum=None, + verbose=True): + r""" + This function can be used to download files from elephant-data using + only the path relative to the root of the elephant-data repository. + The default URL used, points to elephants corresponding release of + elephant-data. + Different versions of the elephant package may require different + versions of elephant-data. + e.g. the follwoing URLs: + - https://web.gin.g-node.org/INM-6/elephant-data/raw/0.0.1 + points to release v0.0.1. + - https://we.gin.g-node.org/INM-6/elephant-data/raw/master + always points to the latest state of elephant-data. + - http://datasets.python-elephant.org/ + points to the root of elephant data + + To change this URL, use the environment variable `ELEPHANT_DATA_URL`. + When using data, which is not yet contained in the master branch or a + release of elephant data, e.g. during development, this variable can + be used to change the default URL. + For example to use data on branch `multitaper`, change the + `ELEPHANT_DATA_URL` to + https://web.gin.g-node.org/INM-6/elephant-data/raw/multitaper. + For a complete example, see Examples section. + + Parameters + ---------- + repo_path : str + String denoting the path relative to elephant-data repository root + filepath : str, optional + Path to temporary folder where the downloaded files will be stored + checksum : str, otpional + Checksum to verify dara integrity after download + verbose : bool, optional + Whether to disable the entire progressbar wrapper []. + If set to None, disable on non-TTY. + Default: True + + Returns + ------- + filepath : pathlib.Path + Path to downloaded files. + + + Notes + ----- + The default URL always points to elephant-data. Please + do not change its value. For development purposes use the environment + variable 'ELEPHANT_DATA_URL'. + + Examples + -------- + The following example downloads a file from elephant-data branch + 'multitaper', by setting the environment variable to the branch URL: + + >>> import os + >>> from elephant.datasets import download_datasets + >>> os.environ["ELEPHANT_DATA_URL"] = "https://web.gin.g-node.org/INM-6/elephant-data/raw/multitaper" # noqa + >>> download_datasets("unittest/spectral/multitaper_psd/data/time_series.npy") + """ + + # this url redirects to the current location of elephant-data + url_to_root = "http://datasets.python-elephant.org/" + + # get URL to corresponding version of elephant data + # (version elephant is equal to version elephant-data) + default_url = url_to_root + f"raw/v{_get_version()}" + + if 'ELEPHANT_DATA_URL' not in environ: # user did not set URL + # is 'version-URL' available? (not for elephant development version) + try: + urlopen(default_url+'/README.md') + + except HTTPError as error: + # if corresponding elephant-data version is not found, + # use latest commit of elephant-data + default_url = url_to_root + f"raw/master" + + warnings.warn(f"No corresponding version of elephant-data found.\n" + f"Elephant version: {_get_version()}. " + f"Data URL:{error.url}, error: {error}.\n" + f"Using elephant-data latest instead (This is " + f"expected for elephant development versions).") + + except URLError as error: + # if verification of SSL certificate fails, do not verify cert + try: # try again without certificate verification + urlopen(default_url + '/README.md', + context=ssl._create_unverified_context()) + except HTTPError as http_error: # e.g. 404: + default_url = url_to_root + f"raw/master" + + warnings.warn(f"Data URL:{default_url}, error: {error}." + f"{error.reason}") + + url = f"{getenv('ELEPHANT_DATA_URL', default_url)}/{repo_path}" + + return download(url, filepath, checksum, verbose) + + +def unzip(filepath, outdir=ELEPHANT_TMP_DIR, verbose=True): + with ZipFile(filepath) as zfile: + zfile.extractall(path=outdir) + if verbose: + print(f"Extracted {filepath} to {outdir}") diff --git a/elephant/test/download.py b/elephant/test/download.py deleted file mode 100644 index 7efcbac8d..000000000 --- a/elephant/test/download.py +++ /dev/null @@ -1,67 +0,0 @@ -import hashlib -import tempfile -from pathlib import Path -from urllib.request import urlretrieve -from zipfile import ZipFile - -from tqdm import tqdm - -ELEPHANT_TMP_DIR = Path(tempfile.gettempdir()) / "elephant" - - -class TqdmUpTo(tqdm): - """ - Provides `update_to(n)` which uses `tqdm.update(delta_n)`. - Original implementation: - https://github.com/tqdm/tqdm/blob/master/examples/tqdm_wget.py - """ - - def update_to(self, b=1, bsize=1, tsize=None): - """ - b : int, optional - Number of blocks transferred so far [default: 1]. - bsize : int, optional - Size of each block (in tqdm units) [default: 1]. - tsize : int, optional - Total size (in tqdm units). If [default: None] remains unchanged. - """ - if tsize is not None: - self.total = tsize - self.update(b * bsize - self.n) # will also set self.n = b * bsize - - -def calculate_md5(filepath, chunk_size=1024 * 1024): - md5 = hashlib.md5() - with open(filepath, 'rb') as f: - for chunk in iter(lambda: f.read(chunk_size), b''): - md5.update(chunk) - return md5.hexdigest() - - -def check_integrity(filepath, md5): - if not Path(filepath).exists() or md5 is None: - return False - return calculate_md5(filepath) == md5 - - -def download(url, filepath=None, checksum=None, verbose=True): - if filepath is None: - filename = url.split('/')[-1] - filepath = ELEPHANT_TMP_DIR / filename - filepath = Path(filepath) - if check_integrity(filepath, md5=checksum): - return filepath - folder = filepath.absolute().parent - folder.mkdir(exist_ok=True) - desc = f"Downloading {url} to '{filepath}'" - with TqdmUpTo(unit='B', unit_scale=True, unit_divisor=1024, miniters=1, - desc=desc, disable=not verbose) as t: - urlretrieve(url, filename=filepath, reporthook=t.update_to) - return filepath - - -def unzip(filepath, outdir=ELEPHANT_TMP_DIR, verbose=True): - with ZipFile(filepath) as zfile: - zfile.extractall(path=outdir) - if verbose: - print(f"Extracted {filepath} to {outdir}") diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index 314f4baab..83659d809 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -15,7 +15,7 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal import elephant.spectral -from elephant.test.download import download, ELEPHANT_TMP_DIR +from elephant.datasets import download_datasets, ELEPHANT_TMP_DIR class WelchPSDTestCase(unittest.TestCase): @@ -254,7 +254,7 @@ def test_multitaper_psd_against_nitime(self): Please follow the link below for more details: https://gin.g-node.org/INM-6/elephant-data/src/master/unittest/spectral/multitaper_psd """ - data_url = r"https://web.gin.g-node.org/INM-6/elephant-data/raw/master/unittest/spectral/multitaper_psd/data" # noqa + repo_path = r"unittest/spectral/multitaper_psd/data" files_to_download = [ ("time_series.npy", "ff43797e2ac94613f510b20a31e2e80e"), @@ -262,7 +262,8 @@ def test_multitaper_psd_against_nitime(self): ] for filename, checksum in files_to_download: - download(url=f"{data_url}/{filename}", checksum=checksum) + download_datasets(repo_path=f"{repo_path}/{filename}", + checksum=checksum) time_series = np.load(ELEPHANT_TMP_DIR / 'time_series.npy') psd_nitime = np.load(ELEPHANT_TMP_DIR / 'psd_nitime.npy') diff --git a/elephant/test/test_spike_train_synchrony.py b/elephant/test/test_spike_train_synchrony.py index 806abcf5c..58be525eb 100644 --- a/elephant/test/test_spike_train_synchrony.py +++ b/elephant/test/test_spike_train_synchrony.py @@ -12,7 +12,7 @@ import elephant.spike_train_generation as stgen from elephant.spike_train_synchrony import Synchrotool, spike_contrast, \ _get_theta_and_n_per_bin, _binning_half_overlap -from elephant.test.download import download, unzip +from elephant.datasets import download_datasets, unzip class TestSpikeContrast(unittest.TestCase): @@ -140,9 +140,9 @@ def test_get_theta_and_n_per_bin(self): [1, 2, 2.5] ] theta, n = _get_theta_and_n_per_bin(spike_trains, - t_start=0, - t_stop=10, - bin_size=5) + t_start=0, + t_stop=10, + bin_size=5) assert_array_equal(theta, [9, 3, 2]) assert_array_equal(n, [3, 3, 2]) @@ -164,11 +164,10 @@ def test_spike_contrast_with_Izhikevich_network_auto(self): # The default unit time is seconds. Each simulation lasted 2 seconds, # starting from 0. - izhikevich_url = r"https://web.gin.g-node.org/INM-6/" \ - r"elephant-data/raw/master/" \ - r"dataset-3/Data_Izhikevich_network.zip" - filepath_zip = download(url=izhikevich_url, - checksum="70e848500c1d9c6403b66de8c741d849") + izhikevich_gin = r"dataset-3/Data_Izhikevich_network.zip" + checksum = "70e848500c1d9c6403b66de8c741d849" + filepath_zip = download_datasets(repo_path=izhikevich_gin, + checksum=checksum) unzip(filepath_zip) filepath_json = filepath_zip.with_suffix(".json") with open(filepath_json) as read_file: diff --git a/elephant/test/test_unitary_event_analysis.py b/elephant/test/test_unitary_event_analysis.py index 02fee6bd4..eba33f976 100644 --- a/elephant/test/test_unitary_event_analysis.py +++ b/elephant/test/test_unitary_event_analysis.py @@ -14,7 +14,7 @@ from numpy.testing import assert_array_equal import elephant.unitary_event_analysis as ue -from elephant.test.download import download, ELEPHANT_TMP_DIR +from elephant.datasets import download, ELEPHANT_TMP_DIR from numpy.testing import assert_array_almost_equal from elephant.spike_train_generation import StationaryPoissonProcess From eb6278b2e36b031bc707067eba008b9714670e46 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 30 Mar 2022 18:07:47 +0200 Subject: [PATCH 49/63] Fix/instantaneous rate (#453) * fixed deprecation warnings, replaced homogeneous_poisson_process with StationaryPoissonProcess * added import for scipy.signal * fixed size of output for instantaneous_rate, edited unittests accordingly * test to check length of outputs * added unittest to check consistency of rate times (should be multiple of sampling period), to get consistent ouput sizes, cutting of wings is done by fft convolve for center_kernel=True * fixed pep8, added comments, restructure * added include endpoint option * added notes to docstrings, reformat docstrings and code, removed endpoint option * fix docstrings * restructured unit tests, added regression tests * fixed pep8 * fixed indentation * fixed wrong return --- elephant/statistics.py | 265 +++++++------ elephant/test/test_spike_train_generation.py | 2 +- elephant/test/test_statistics.py | 371 ++++++++++++------- 3 files changed, 374 insertions(+), 264 deletions(-) diff --git a/elephant/statistics.py b/elephant/statistics.py index 6ad8bb3bc..314c3215c 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -74,6 +74,7 @@ import numpy as np import quantities as pq import scipy.stats +import scipy.signal from scipy.special import erf import elephant.conversion as conv @@ -603,13 +604,12 @@ def lvr(time_intervals, R=5*pq.ms, with_nan=False): def instantaneous_rate(spiketrains, sampling_period, kernel='auto', cutoff=5.0, t_start=None, t_stop=None, trim=False, center_kernel=True, border_correction=False): - """ + r""" Estimates instantaneous firing rate by kernel convolution. Visualization of this function is covered in Viziphant: :func:`viziphant.statistics.plot_instantaneous_rates_colormesh`. - Parameters ---------- spiketrains : neo.SpikeTrain or list of neo.SpikeTrain @@ -622,7 +622,7 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', The string 'auto' or callable object of class `kernels.Kernel`. The kernel is used for convolution with the spike train and its standard deviation determines the time resolution of the instantaneous - rate estimation. Currently implemented kernel forms are rectangular, + rate estimation. Currently, implemented kernel forms are rectangular, triangular, epanechnikovlike, gaussian, laplacian, exponential, and alpha function. If 'auto', the optimized kernel width for the rate estimation is @@ -630,29 +630,34 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Gaussian kernel is constructed with this width. Automatized calculation of the kernel width is not available for other than Gaussian kernel shapes. + Note: The kernel width is not adaptive, i.e., it is calculated as global optimum across the data. + Default: 'auto' cutoff : float, optional This factor determines the cutoff of the probability distribution of the kernel, i.e., the considered width of the kernel in terms of multiples of the standard deviation sigma. + Default: 5.0 t_start : pq.Quantity, optional Start time of the interval used to compute the firing rate. If None, `t_start` is assumed equal to `t_start` attribute of `spiketrain`. + Default: None t_stop : pq.Quantity, optional - End time of the interval used to compute the firing rate (included). + End time of the interval used to compute the firing rate. If None, `t_stop` is assumed equal to `t_stop` attribute of `spiketrain`. + Default: None trim : bool, optional Accounts for the asymmetry of a kernel. If False, the output of the Fast Fourier Transformation being a longer - vector than the input vector by the size of the kernel is reduced back - to the original size of the considered time interval of the + vector than the input vector (ouput = input + kernel - 1) is reduced + back to the original size of the considered time interval of the `spiketrain` using the median of the kernel. False (no trimming) is equivalent to 'same' convolution mode for symmetrical kernels. If True, only the region of the convolved signal is returned, where @@ -661,12 +666,14 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Transformation by a total of two times the size of the kernel, and `t_start` and `t_stop` are adjusted. True (trimming) is equivalent to 'valid' convolution mode for symmetrical kernels. + Default: False center_kernel : bool, optional If set to True, the kernel will be translated such that its median is centered on the spike, thus putting equal weight before and after the spike. If False, no adjustment is performed such that the spike sits at the origin of the kernel. + Default: True border_correction : bool, optional Apply a border correction to prevent underestimating the firing rates @@ -689,35 +696,51 @@ def instantaneous_rate(spiketrains, sampling_period, kernel='auto', Raises ------ TypeError - If `spiketrain` is not an instance of `neo.SpikeTrain`. + * If `spiketrain` is not an instance of `neo.SpikeTrain`. + * If `sampling_period` is not a `pq.Quantity`. + * If `sampling_period` is not larger than zero. + * If `kernel` is neither instance of `kernels.Kernel` nor string + 'auto'. + * If `cutoff` is neither `float` nor `int`. + * If `t_start` and `t_stop` are neither None nor a `pq.Quantity`. + * If `trim` is not `bool`. + ValueError + * If `sampling_period` is smaller than zero. + * If `kernel` is 'auto' and the function was unable to calculate + optimal kernel width for instantaneous rate from input data. - If `sampling_period` is not a `pq.Quantity`. + Warns + ----- + UserWarning + * If `cutoff` is less than `min_cutoff` attribute of `kernel`, the + width of the kernel is adjusted to a minimally allowed width. - If `sampling_period` is not larger than zero. + Notes + ----- + * The resulting instantaneous firing rate values smaller than ``0``, which + may happen due to machine precision errors, are clipped to zero. - If `kernel` is neither instance of `kernels.Kernel` nor string 'auto'. + * The instantaneous firing rate estimate is calculated based on half-open + intervals ``[)``, except the last one e.g. if ``t_start = 0s``, + ``t_stop = 4s`` and ``sampling_period = 1s``, the intervals are: - If `cutoff` is neither `float` nor `int`. + ``[0, 1)`` ``[1, 2)`` ``[2, 3)`` ``[3, 4]``. - If `t_start` and `t_stop` are neither None nor a `pq.Quantity`. + This induces a sampling bias, which can lead to a time shift of the + estimated rate, if the `sampling_period` is chosen large relative to the + duration ``(t_stop - t_start)``. One possibility to counteract this is + to choose a smaller `sampling_period`. - If `trim` is not `bool`. - ValueError - If `sampling_period` is smaller than zero. + * The last interval of the given duration ``(t_stop - t_start)`` is + dropped if it is shorter than `sampling_period`, + e.g. if ``t_start = 0s``, ``t_stop = 4.5s`` and + ``sampling_period = 1s``, the intervals considered are: - If `kernel` is 'auto' and the function was unable to calculate optimal - kernel width for instantaneous rate from input data. + ``[0, 1)`` ``[1, 2)`` ``[2, 3)`` ``[3, 4]``, + + the last interval ``[4, 4.5]`` is excluded from all calculations. - Warns - ----- - UserWarning - If `cutoff` is less than `min_cutoff` attribute of `kernel`, the width - of the kernel is adjusted to a minimally allowed width. - Notes - ----- - The resulting instantaneous firing rate values smaller than ``0``, which - can happen due to machine precision errors, are clipped to zero. Examples -------- @@ -787,32 +810,29 @@ def optimal_kernel(st): if kernel == 'auto': kernel = optimal_kernel(spiketrains) spiketrains = [spiketrains] - elif not isinstance(spiketrains, (list, tuple, SpikeTrainList)): - raise TypeError( - "'spiketrains' must be a list of neo.SpikeTrain's or a single " - "neo.SpikeTrain. Found: '{}'".format(type(spiketrains))) + + if not all([isinstance(elem, neo.SpikeTrain) for elem in spiketrains]): + raise TypeError(f"'spiketrains' must be a list of neo.SpikeTrain's or " + f"a single neo.SpikeTrain. Found: {type(spiketrains)}") if not is_time_quantity(sampling_period): - raise TypeError( - "The 'sampling_period' must be a time Quantity. \n" - "Found: {}".format(type(sampling_period))) + raise TypeError(f"The 'sampling_period' must be a time Quantity." + f"Found: {type(sampling_period)}") if sampling_period.magnitude < 0: - raise ValueError("The 'sampling_period' ({}) must be non-negative.". - format(sampling_period)) + raise ValueError(f"The 'sampling_period' ({sampling_period}) " + f"must be non-negative.") if not (isinstance(kernel, kernels.Kernel) or kernel == 'auto'): - raise TypeError( - "'kernel' must be either instance of class elephant.kernels.Kernel" - " or the string 'auto'. Found: %s, value %s" % (type(kernel), - str(kernel))) + raise TypeError(f"'kernel' must be instance of class " + f"elephant.kernels.Kernel or string 'auto'. Found: " + f"{type(kernel)}, value {str(kernel)}") if not isinstance(cutoff, (float, int)): raise TypeError("'cutoff' must be float or integer") if not is_time_quantity(t_start, allow_none=True): raise TypeError("'t_start' must be a time Quantity") - if not is_time_quantity(t_stop, allow_none=True): raise TypeError("'t_stop' must be a time Quantity") @@ -822,6 +842,7 @@ def optimal_kernel(st): check_neo_consistency(spiketrains, object_type=neo.SpikeTrain, t_start=t_start, t_stop=t_stop) + if kernel == 'auto': if len(spiketrains) == 1: kernel = optimal_kernel(spiketrains[0]) @@ -835,77 +856,77 @@ def optimal_kernel(st): if t_stop is None: t_stop = spiketrains[0].t_stop - units = pq.CompoundUnit( - "{}*s".format(sampling_period.rescale('s').item())) + # Rescale units for consistent calculation t_start = t_start.rescale(spiketrains[0].units) t_stop = t_stop.rescale(spiketrains[0].units) - n_bins = int(((t_stop - t_start) / sampling_period).simplified) + 1 - time_vectors = np.zeros((len(spiketrains), n_bins), dtype=np.float64) - hist_range_end = t_stop + sampling_period.rescale(spiketrains[0].units) + # Calculate parameters for np.histogram + n_bins = int(((t_stop - t_start) / sampling_period).simplified) + hist_range_end = t_start + n_bins * \ + sampling_period.rescale(spiketrains[0].units) + hist_range = (t_start.item(), hist_range_end.item()) + + # Preallocation + histogram_arr = np.zeros((len(spiketrains), n_bins), dtype=np.float64) for i, st in enumerate(spiketrains): - time_vectors[i], _ = np.histogram(st.magnitude, bins=n_bins, - range=hist_range) + histogram_arr[i], _ = np.histogram(st.magnitude, bins=n_bins, + range=hist_range) + + histogram_arr = histogram_arr.T # make it (time, units) + # Kernel if cutoff < kernel.min_cutoff: cutoff = kernel.min_cutoff warnings.warn("The width of the kernel was adjusted to a minimally " "allowed width.") - # An odd number of points correctly resolves the median index and the - # fact that the peak of an instantaneous rate should be centered at t=0 - # for symmetric kernels applied on a single spike at t=0. - # See issue https://github.com/NeuralEnsemble/elephant/issues/360 - n_half = math.ceil(cutoff * ( - kernel.sigma / sampling_period).simplified.item()) - cutoff_sigma = cutoff * kernel.sigma.rescale(units).magnitude - if center_kernel: - # t_arr must be centered at the kernel median. - # Not centering on the kernel median leads to underestimating the - # instantaneous rate in cases when sampling_period >> kernel.sigma. - median = kernel.icdf(0.5).rescale(units).item() + scaling_unit = pq.CompoundUnit(f"{sampling_period.rescale('s').item()}*s") + cutoff_sigma = cutoff * kernel.sigma.rescale(scaling_unit).magnitude + if center_kernel: # t_arr is centered on the kernel median. + median = kernel.icdf(0.5).rescale(scaling_unit).item() else: median = 0 - t_arr = np.linspace(-cutoff_sigma + median, stop=cutoff_sigma + median, - num=2 * n_half + 1, endpoint=True) * units - - if center_kernel: - # keep the full convolve range and do the trimming afterwards; - # trimming is performed according to the kernel median index - fft_mode = 'full' - elif trim: - # no median index trimming is involved + + # An odd number of points correctly resolves the median index of the + # kernel. This avoids a timeshift in the rate estimate for symmetric + # kernels. A number x given by 'x = 2 * n + 1' with n being an integer is + # always odd. Using `math.ceil` to calculate `t_arr_kernel_half` ensures an + # integer value, hence the number of points for the kernel (num) given by + # `num=2 * t_arr_kernel_half + 1` is always odd. + # (See Issue #360, https://github.com/NeuralEnsemble/elephant/issues/360) + t_arr_kernel_half = math.ceil( + cutoff * (kernel.sigma / sampling_period).simplified.item()) + t_arr_kernel_length = 2 * t_arr_kernel_half + 1 + + # Shift kernel using the calculated median + t_arr_kernel = np.linspace(start=-cutoff_sigma + median, + stop=cutoff_sigma + median, + num=t_arr_kernel_length, + endpoint=True) * scaling_unit + + # Calculate the kernel values with t_arr + kernel_arr = np.expand_dims( + kernel(t_arr_kernel).rescale(pq.Hz).magnitude, axis=1) + + # Define mode for scipy.signal.fftconvolve + if trim: fft_mode = 'valid' else: - # no median index trimming is involved fft_mode = 'same' - time_vectors = time_vectors.T # make it (time, units) - kernel_arr = np.expand_dims(kernel(t_arr).rescale(pq.Hz).magnitude, axis=1) - rate = scipy.signal.fftconvolve(time_vectors, + rate = scipy.signal.fftconvolve(histogram_arr, kernel_arr, mode=fft_mode) - # the convolution of non-negative vectors is non-negative + # The convolution of non-negative vectors is non-negative rate = np.clip(rate, a_min=0, a_max=None, out=rate) - if center_kernel: # account for the kernel asymmetry - median_id = kernel.median_index(t_arr) - # the size of kernel() output matches the input size, len(t_arr) - kernel_array_size = len(t_arr) - if not trim: - rate = rate[median_id: -kernel_array_size + median_id] - else: - rate = rate[2 * median_id: -2 * (kernel_array_size - median_id)] - t_start = t_start + median_id * units - t_stop = t_stop - (kernel_array_size - median_id) * units - else: - # FIXME: don't shrink the output array - # (to be consistent with center_kernel=True) - # n points have n-1 intervals; - # instantaneous rate is a list of intervals; - # hence, the last element is excluded - rate = rate[:-1] + # Adjust t_start and t_stop + if fft_mode == 'valid': + median_id = kernel.median_index(t_arr_kernel) + kernel_array_size = len(kernel_arr) + t_start = t_start + median_id * scaling_unit + t_stop = t_stop - (kernel_array_size - median_id) * scaling_unit kernel_annotation = dict(type=type(kernel).__name__, sigma=str(kernel.sigma), @@ -968,10 +989,11 @@ def time_histogram(spiketrains, bin_size, t_start=None, t_stop=None, Default: None output : {'counts', 'mean', 'rate'}, optional Normalization of the histogram. Can be one of: - * 'counts': spike counts at each bin (as integer numbers) - * 'mean': mean spike counts per spike train - * 'rate': mean spike rate per spike train. Like 'mean', but the - counts are additionally normalized by the bin width. + * 'counts': spike counts at each bin (as integer numbers). + * 'mean': mean spike counts per spike train. + * 'rate': mean spike rate per spike train. Like 'mean', but the + counts are additionally normalized by the bin width. + Default: 'counts' binary : bool, optional If True, indicates whether all `neo.SpikeTrain` objects should first @@ -1120,25 +1142,28 @@ class Complexity(object): bin_size : pq.Quantity or None, optional Width of the histogram's time bins with units of time. The user must specify the `bin_size` or the `sampling_rate`. - * If None and the `sampling_rate` is available - 1/`sampling_rate` is used. - * If both are given then `bin_size` is used. + * If None and the `sampling_rate` is available + 1/`sampling_rate` is used. + * If both are given then `bin_size` is used. + Default: None binary : bool, optional - * If True then the time histograms will be binary. - * If False the total number of synchronous spikes is counted in the - time histogram. + * If True then the time histograms will be binary. + * If False the total number of synchronous spikes is counted in the + time histogram. + Default: True spread : int, optional Number of bins in which to check for synchronous spikes. Spikes that occur separated by `spread - 1` or less empty bins are considered synchronous. - * ``spread = 0`` corresponds to a bincount accross spike trains. - * ``spread = 1`` corresponds to counting consecutive spikes. - * ``spread = 2`` corresponds to counting consecutive spikes and - spikes separated by exactly 1 empty bin. - * ``spread = n`` corresponds to counting spikes separated by exactly - or less than `n - 1` empty bins. + * ``spread = 0`` corresponds to a bincount accross spike trains. + * ``spread = 1`` corresponds to counting consecutive spikes. + * ``spread = 2`` corresponds to counting consecutive spikes and + spikes separated by exactly 1 empty bin. + * ``spread = n`` corresponds to counting spikes separated by exactly + or less than `n - 1` empty bins. + Default: 0 tolerance : float or None, optional Tolerance for rounding errors in the binning process and in the input @@ -1151,18 +1176,20 @@ class Complexity(object): epoch : neo.Epoch An epoch object containing complexity values, left edges and durations of all intervals with at least one spike. - * ``epoch.array_annotations['complexity']`` contains the - complexity values per spike. - * ``epoch.times`` contains the left edges. - * ``epoch.durations`` contains the durations. + * ``epoch.array_annotations['complexity']`` contains the + complexity values per spike. + * ``epoch.times`` contains the left edges. + * ``epoch.durations`` contains the durations. + time_histogram : neo.Analogsignal A `neo.AnalogSignal` object containing the histogram values. `neo.AnalogSignal[j]` is the histogram computed between `t_start + j * binsize` and `t_start + (j + 1) * binsize`. - * If ``binary = True`` : Number of neurons that spiked in each bin, - regardless of the number of spikes. - * If ``binary = False`` : Number of neurons and spikes per neurons - in each bin. + * If ``binary = True`` : Number of neurons that spiked in each bin, + regardless of the number of spikes. + * If ``binary = False`` : Number of neurons and spikes per neurons + in each bin. + complexity_histogram : np.ndarray The number of occurrences of events of different complexities. `complexity_hist[i]` corresponds to the number of events of @@ -1196,11 +1223,11 @@ class Complexity(object): Notes ----- - * Note that with most common parameter combinations spike times can end up - on bin edges. This makes the binning susceptible to rounding errors which - is accounted for by moving spikes which are within tolerance of the next - bin edge into the following bin. This can be adjusted using the tolerance - parameter and turned off by setting `tolerance=None`. + Note that with most common parameter combinations spike times can end up + on bin edges. This makes the binning susceptible to rounding errors which + is accounted for by moving spikes which are within tolerance of the next + bin edge into the following bin. This can be adjusted using the tolerance + parameter and turned off by setting `tolerance=None`. See also -------- diff --git a/elephant/test/test_spike_train_generation.py b/elephant/test/test_spike_train_generation.py index 457e376c6..6a1434a2e 100644 --- a/elephant/test/test_spike_train_generation.py +++ b/elephant/test/test_spike_train_generation.py @@ -864,7 +864,7 @@ def test_recovered_firing_rate_profile(self): rate_recovered = rate_recovered.flatten().magnitude trim = (rate_profile.shape[0] - rate_recovered.shape[0]) // 2 rate_profile_valid = rate_profile.magnitude.squeeze() - rate_profile_valid = rate_profile_valid[trim: -trim - 1] + rate_profile_valid = rate_profile_valid[trim: -trim] assert_allclose(rate_recovered, rate_profile_valid, rtol=0, atol=rtol * rate.item()) diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index d693e604e..1c7649593 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -22,7 +22,7 @@ from elephant.spike_train_generation import StationaryPoissonProcess -class isi_TestCase(unittest.TestCase): +class IsiTestCase(unittest.TestCase): def setUp(self): self.test_array_2d = np.array([[0.3, 0.56, 0.87, 1.23], [0.02, 0.71, 1.82, 8.46], @@ -82,10 +82,10 @@ def test_unsorted_array(self): np.random.seed(0) array = np.random.rand(100) with self.assertWarns(UserWarning): - isi = statistics.isi(array) + statistics.isi(array) -class isi_cv_TestCase(unittest.TestCase): +class IsiCvTestCase(unittest.TestCase): def setUp(self): self.test_array_regular = np.arange(1, 6) @@ -102,7 +102,7 @@ def test_cv_isi_regular_array_is_zero(self): self.assertEqual(res, targ) -class mean_firing_rate_TestCase(unittest.TestCase): +class MeanFiringRateTestCase(unittest.TestCase): def setUp(self): self.test_array_3d = np.ones([5, 7, 13]) self.test_array_2d = np.array([[0.3, 0.56, 0.87, 1.23], @@ -504,67 +504,77 @@ def setUp(self): # generation of a multiply used specific kernel self.kernel = kernels.TriangularKernel(sigma=0.03 * pq.s) + # calculate instantaneous rate + self.sampling_period = 0.01 * pq.s + self.inst_rate = statistics.instantaneous_rate( + self.spike_train, self.sampling_period, self.kernel, cutoff=0) - def test_instantaneous_rate_and_warnings(self): - st = self.spike_train - sampling_period = 0.01 * pq.s + def test_instantaneous_rate_warnings(self): with self.assertWarns(UserWarning): # Catches warning: The width of the kernel was adjusted to a # minimally allowed width. - inst_rate = statistics.instantaneous_rate( - st, sampling_period, self.kernel, cutoff=0) - self.assertIsInstance(inst_rate, neo.core.AnalogSignal) - self.assertEqual( - inst_rate.sampling_period.simplified, sampling_period.simplified) - self.assertEqual(inst_rate.simplified.units, pq.Hz) - self.assertEqual(inst_rate.t_stop.simplified, st.t_stop.simplified) - self.assertEqual(inst_rate.t_start.simplified, st.t_start.simplified) + statistics.instantaneous_rate(self.spike_train, + self.sampling_period, + self.kernel, cutoff=0) - def test_error_instantaneous_rate(self): - self.assertRaises( + def test_instantaneous_rate_errors(self): + self.assertRaises( # input is not neo.SpikeTrain TypeError, statistics.instantaneous_rate, spiketrains=[1, 2, 3] * pq.s, sampling_period=0.01 * pq.ms, kernel=self.kernel) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=[1, 2, 3], - sampling_period=0.01 * pq.ms, kernel=self.kernel) - st = self.spike_train - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01, kernel=self.kernel) - self.assertRaises( - ValueError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=-0.01 * pq.ms, kernel=self.kernel) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01 * pq.ms, kernel='NONE') - self.assertRaises(TypeError, statistics.instantaneous_rate, - self.spike_train, - sampling_period=0.01 * pq.s, kernel='wrong_string', - t_start=self.st_tr[0] * pq.s, - t_stop=self.st_tr[1] * pq.s, - trim=False) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01 * pq.ms, kernel=self.kernel, - cutoff=20 * pq.ms) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01 * pq.ms, kernel=self.kernel, t_start=2) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01 * pq.ms, kernel=self.kernel, - t_stop=20 * pq.mV) - self.assertRaises( - TypeError, statistics.instantaneous_rate, spiketrains=st, - sampling_period=0.01 * pq.ms, kernel=self.kernel, trim=1) - - # cannot estimate a kernel for a list of spiketrains - self.assertRaises(ValueError, statistics.instantaneous_rate, - spiketrains=[st, st], sampling_period=10 * pq.ms, - kernel='auto') - - def test_rate_estimation_consistency(self): + self.assertRaises( # sampling period is not time quantity + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, kernel=self.kernel, + sampling_period=0.01) + self.assertRaises( # sampling period is < 0 + ValueError, statistics.instantaneous_rate, + spiketrains=self.spike_train, kernel=self.kernel, + sampling_period=-0.01 * pq.ms) + self.assertRaises( # no kernel or kernel='auto' + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.ms, + kernel='NONE') + self.assertRaises( # wrong string for kernel='string' + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.s, + kernel='wrong_string') + self.assertRaises( # cutoff is not float or int + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.ms, + kernel=self.kernel, cutoff=20 * pq.ms) + self.assertRaises( # t_start not time quantity + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.ms, + kernel=self.kernel, t_start=2) + self.assertRaises( # t_stop not time quantity + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.ms, + kernel=self.kernel, t_stop=20 * pq.mV) + self.assertRaises( # trim is not bool + TypeError, statistics.instantaneous_rate, + spiketrains=self.spike_train, sampling_period=0.01 * pq.ms, + kernel=self.kernel, trim=1) + self.assertRaises( # can't estimate a kernel for a list of spiketrains + ValueError, statistics.instantaneous_rate, + spiketrains=[self.spike_train, self.spike_train], + sampling_period=10 * pq.ms, kernel='auto') + + def test_instantaneous_rate_output(self): + # return type correct + self.assertIsInstance(self.inst_rate, neo.core.AnalogSignal) + # sampling_period input and output same + self.assertEqual(self.inst_rate.sampling_period.simplified, + self.sampling_period.simplified) + # return correct units pq.Hz + self.assertEqual(self.inst_rate.simplified.units, pq.Hz) + # input and output t_stop same + self.assertEqual(self.spike_train.t_stop.simplified, + self.inst_rate.t_stop.simplified) + # input and output t_start same + self.assertEqual(self.inst_rate.t_start.simplified, + self.spike_train.t_start.simplified) + + def test_instantaneous_rate_rate_estimation_consistency(self): """ Test, whether the integral of the rate estimation curve is (almost) equal to the number of spikes of the spike train. @@ -575,6 +585,7 @@ def test_rate_estimation_consistency(self): issubclass(kern_cls, kernels.Kernel) and kern_cls is not kernels.Kernel and kern_cls is not kernels.SymmetricKernel) + # set sigma kernels_available = [kern_cls(sigma=0.5 * pq.s, invert=False) for kern_cls in kernel_types] kernels_available.append('auto') @@ -595,45 +606,54 @@ def test_rate_estimation_consistency(self): border_correction=border_correction ) num_spikes = len(self.spike_train) - auc = spint.cumtrapz( + area_under_curve = spint.cumtrapz( y=rate_estimate.magnitude[:, 0], x=rate_estimate.times.rescale('s').magnitude)[-1] - self.assertAlmostEqual(num_spikes, auc, + self.assertAlmostEqual(num_spikes, area_under_curve, delta=0.01 * num_spikes) - def test_not_center_kernel(self): - # issue 107 + def test_instantaneous_rate_regression_107(self): + # Create a spiketrain with t_start=0s, t_stop=2s and a single spike at + # t=1s. Now choose an asymmetric kernel starting at t=0 to avoid a rise + # in firing rate before the response onset, so to say to avoid 'looking + # into the future' from the perspective of the neuron. t_spike = 1 * pq.s - st = neo.SpikeTrain([t_spike], t_start=0 * pq.s, t_stop=2 * pq.s, - units=pq.s) + spiketrain = neo.SpikeTrain( + [t_spike], t_start=0 * pq.s, t_stop=2 * pq.s, units=pq.s) kernel = kernels.AlphaKernel(200 * pq.ms) - fs = 0.1 * pq.ms - rate = statistics.instantaneous_rate(st, - sampling_period=fs, - kernel=kernel, - center_kernel=False) + sampling_period = 0.1 * pq.ms + rate = statistics.instantaneous_rate( + spiketrains=spiketrain, sampling_period=sampling_period, + kernel=kernel, center_kernel=False) + # find positive nonezero rate estimates rate_nonzero_index = np.nonzero(rate > 1e-6)[0] - # where the mass is concentrated - rate_mass = rate.times.rescale(t_spike.units)[rate_nonzero_index] - all_after_response_onset = (rate_mass >= t_spike).all() + # find times, where the mass is concentrated, i.e. rate is estimated>0 + rate_mass_times = rate.times.rescale(t_spike.units)[rate_nonzero_index] + # all times, where rate is >0 should occur after response onset + # (t_spike is at 1s) + all_after_response_onset = (rate_mass_times >= t_spike).all() self.assertTrue(all_after_response_onset) - def test_regression_288(self): - np.random.seed(9) - sampling_period = 200 * pq.ms - spiketrain = StationaryPoissonProcess( - 10 * pq.Hz, t_start=0 * pq.s, t_stop=10 * pq.s - ).generate_spiketrain() - kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) + def test_instantaneous_rate_regression_288(self): # check that instantaneous_rate "works" for kernels with small sigma - # without triggering an incomprehensible error - rate = statistics.instantaneous_rate(spiketrain, - sampling_period=sampling_period, - kernel=kernel) - self.assertEqual( - len(rate), (spiketrain.t_stop / sampling_period).simplified.item()) - - def test_small_kernel_sigma(self): + # without triggering an incomprehensible error: + # ValueError: zero-size array to reduction operation minimum which has + # no identity + try: + np.random.seed(9) + sampling_period = 200 * pq.ms + spiketrain = StationaryPoissonProcess( + 10 * pq.Hz, t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() + kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True) + rate = statistics.instantaneous_rate( + spiketrain, sampling_period=sampling_period, kernel=kernel) + except ValueError: + self.fail('When providing a kernel on a much smaller time scale ' + 'than sampling rate requested the instantaneous rate ' + 'estimation will fail on numpy level ') + + def test_instantaneous_rate_small_kernel_sigma(self): # Test that the instantaneous rate is overestimated when # kernel.sigma << sampling_period and center_kernel is True. # The setup is set to match the issue 288. @@ -642,8 +662,9 @@ def test_small_kernel_sigma(self): sigma = 5 * pq.ms rate_expected = 10 * pq.Hz spiketrain = StationaryPoissonProcess( - rate_expected, t_start=0 * pq.s, t_stop=10 * pq.s - ).generate_spiketrain() + rate_expected, t_start=0 * pq.s, + t_stop=10 * pq.s).generate_spiketrain() + kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() if isinstance(kern_cls, type) and @@ -659,13 +680,14 @@ def test_small_kernel_sigma(self): kernel=kernel, center_kernel=True) self.assertGreater(rate.mean(), rate_expected) - def test_spikes_on_edges(self): + def test_instantaneous_rate_spikes_on_edges(self): # this test demonstrates that the trimming (convolve valid mode) - # removes the edge spikes, underestimating the true firing rate and - # thus is not able to reconstruct the number of spikes in a - # spiketrain (see test_rate_estimation_consistency) + # removes the edges of the rate estimate, underestimating the true + # firing rate and thus is not able to reconstruct the number of spikes + # in a spiketrain (see test_rate_estimation_consistency) cutoff = 5 sampling_period = 0.01 * pq.s + # with t_spikes = [-5, 5]s the isi is 10s, so 1/isi 0.1 Hz t_spikes = np.array([-cutoff, cutoff]) * pq.s spiketrain = neo.SpikeTrain(t_spikes, t_start=t_spikes[0], t_stop=t_spikes[-1]) @@ -685,9 +707,14 @@ def test_spikes_on_edges(self): kernel=kernel, cutoff=cutoff, trim=True, center_kernel=center_kernel) - assert_array_almost_equal(rate.magnitude, 0, decimal=3) - - def test_trim_as_convolve_mode(self): + assert_array_almost_equal(rate.magnitude, 0, decimal=2) + + def test_instantaneous_rate_center_kernel(self): + # this test is obsolete since trimming is now always done by + # np.fftconvolve, in earlier version trimming was implemented for + # center_kernel = True + # This test now verifies, that an already centered kernel is not + # affected by center_kernel = True. cutoff = 5 sampling_period = 0.01 * pq.s t_spikes = np.linspace(-cutoff, cutoff, num=(2 * cutoff + 1)) * pq.s @@ -706,15 +733,16 @@ def test_trim_as_convolve_mode(self): for trim in (False, True): rate_centered = statistics.instantaneous_rate( spiketrain, sampling_period=sampling_period, - kernel=kernel, cutoff=cutoff, trim=trim) + kernel=kernel, cutoff=cutoff, trim=trim, + center_kernel=True) - rate_convolve = statistics.instantaneous_rate( + rate_not_centered = statistics.instantaneous_rate( spiketrain, sampling_period=sampling_period, kernel=kernel, cutoff=cutoff, trim=trim, center_kernel=False) - assert_array_almost_equal(rate_centered, rate_convolve) + assert_array_almost_equal(rate_centered, rate_not_centered) - def test_instantaneous_rate_spiketrainlist(self): + def test_instantaneous_rate_list_of_spiketrains(self): np.random.seed(19) duration_effective = self.st_dur - 2 * self.st_margin st_num_spikes = np.random.poisson(self.st_rate * duration_effective) @@ -725,37 +753,37 @@ def test_instantaneous_rate_spiketrainlist(self): spike_train2 = neo.SpikeTrain(spike_train2 * pq.s, t_start=self.st_tr[0] * pq.s, t_stop=self.st_tr[1] * pq.s) - st_rate_1 = statistics.instantaneous_rate(self.spike_train, - sampling_period=0.01 * pq.s, - kernel=self.kernel) - st_rate_2 = statistics.instantaneous_rate(spike_train2, - sampling_period=0.01 * pq.s, - kernel=self.kernel) + + st_rate_1 = statistics.instantaneous_rate( + self.spike_train, sampling_period=self.sampling_period, + kernel=self.kernel) + st_rate_2 = statistics.instantaneous_rate( + spike_train2, sampling_period=self.sampling_period, + kernel=self.kernel) + rate_concat = np.c_[st_rate_1, st_rate_2] + combined_rate = statistics.instantaneous_rate( [self.spike_train, spike_train2], - sampling_period=0.01 * pq.s, + sampling_period=self.sampling_period, kernel=self.kernel) - rate_concat = np.c_[st_rate_1, st_rate_2] # 'time_vector.dtype' in instantaneous_rate() is changed from float64 # to float32 which results in 3e-6 abs difference assert_array_almost_equal(combined_rate.magnitude, rate_concat.magnitude, decimal=5) - # Regression test for #144 def test_instantaneous_rate_regression_144(self): # The following spike train contains spikes that are so close to each # other, that the optimal kernel cannot be detected. Therefore, the # function should react with a ValueError. st = neo.SpikeTrain([2.12, 2.13, 2.15] * pq.s, t_stop=10 * pq.s) - self.assertRaises(ValueError, statistics.instantaneous_rate, st, - 1 * pq.ms) + self.assertRaises( + ValueError, statistics.instantaneous_rate, st, 1 * pq.ms) - # Regression test for #245 def test_instantaneous_rate_regression_245(self): # This test makes sure that the correct kernel width is chosen when # selecting 'auto' as kernel spiketrain = neo.SpikeTrain( - range(1, 30) * pq.ms, t_start=0 * pq.ms, t_stop=30 * pq.ms) + pq.ms * range(1, 30), t_start=0 * pq.ms, t_stop=30 * pq.ms) # This is the correct procedure to attain the kernel: first, the result # of sskernel retrieves the kernel bandwidth of an optimal Gaussian @@ -789,17 +817,16 @@ def test_instantaneous_rate_grows_with_sampling_period(self): for sampling_period in np.linspace(1, 1000, num=10) * pq.ms: with self.subTest(sampling_period=sampling_period): rate = statistics.instantaneous_rate( - spiketrain, - sampling_period=sampling_period, - kernel=kernel) + spiketrain, sampling_period=sampling_period, kernel=kernel) rates_mean.append(rate.mean()) # rate means are greater or equal the expected rate assert_array_less(rate_expected, rates_mean) # check sorted self.assertTrue(np.all(rates_mean[:-1] < rates_mean[1:])) - # Regression test for #360 - def test_centered_at_origin(self): + def test_instantaneous_rate_regression_360(self): + # This test check if the resulting rate is centered for a spiketrain + # with spikes at [-0.0001, 0, 0.0001]. # Skip RectangularKernel because it doesn't have a strong peak. kernel_types = tuple( kern_cls for kern_cls in kernels.__dict__.values() @@ -818,11 +845,11 @@ def test_centered_at_origin(self): rate = statistics.instantaneous_rate(spiketrain, sampling_period=20 * pq.ms, kernel=kernel) - # the peak time must be centered at origin + # the peak time must be centered at origin t=0 self.assertEqual(rate.times[np.argmax(rate)], 0) # second part: a single spike at t=0 - periods = [2 ** c for c in range(-3, 6)] + periods = [2 ** exp for exp in range(-3, 6)] for period in periods: with self.subTest(period=period): spiketrain = neo.SpikeTrain(np.array([0]) * pq.s, @@ -835,7 +862,7 @@ def test_centered_at_origin(self): kernel=kernel) self.assertEqual(rate.times[np.argmax(rate)], 0) - def test_annotations(self): + def test_instantaneous_rate_annotations(self): spiketrain = neo.SpikeTrain([1, 2], t_stop=2 * pq.s, units=pq.s) kernel = kernels.AlphaKernel(sigma=100 * pq.ms) rate = statistics.instantaneous_rate(spiketrain, @@ -847,30 +874,86 @@ def test_annotations(self): self.assertIn('kernel', rate.annotations) self.assertEqual(rate.annotations['kernel'], kernel_annotation) - def test_border_correction(self): - np.random.seed(0) - n_spiketrains = 125 - rate = 50. * pq.Hz - t_start = 0. * pq.ms - t_stop = 1000. * pq.ms - - sampling_period = 0.1 * pq.ms - - trial_list = StationaryPoissonProcess( - rate=rate, t_start=t_start, t_stop=t_stop - ).generate_n_spiketrains(n_spiketrains) - - for correction in (True, False): - rates = [] - for trial in trial_list: - # calculate the instantaneous rate, discard extra dimension - instantaneous_rate = statistics.instantaneous_rate( - spiketrains=trial, - sampling_period=sampling_period, - kernel='auto', - border_correction=correction - ) - rates.append(instantaneous_rate) + def test_instantaneous_rate_regression_374(self): + # Check if the last interval is dropped. + # In this example a spiketrain with t_start=0, t_stop=9.8, and spikes + # at [9.65, 9.7, 9.75]s is used. When calculating the rate estimate + # with a sampling_period of 1s, the last interval [9.0, 9.8) should be + # dropped and not be considered in the calculation. + spike_times = np.array([9.65, 9.7, 9.75]) * pq.s + + spiketrain = neo.SpikeTrain(spike_times, + t_start=0, + t_stop=9.8) + kernel = kernels.GaussianKernel(sigma=250 * pq.ms) + sampling_period = 1000 * pq.ms + rate = statistics.instantaneous_rate( + spiketrain, + sampling_period=sampling_period, + kernel=kernel, center_kernel=False, trim=False, cutoff=1) + assert_array_almost_equal(rate.magnitude, 0) + + def test_instantaneous_rate_rate_times(self): + # check if the differences between the rate.times is equal to + # sampling_period + st = self.spike_train + periods = [1, 0.99, 0.35, 11, st.duration]*pq.s + for period in periods: + rate = statistics.instantaneous_rate(st, + sampling_period=period, + kernel=self.kernel, + center_kernel=True, + trim=False) + rate_times_diff = np.diff(rate.times) + period_times = np.full_like(rate_times_diff, period) + assert_array_almost_equal(rate_times_diff, period_times) + + def test_instantaneous_rate_bin_edges(self): + # This test checks if the bin edges used to calculate the rate estimate + # are multiples of the sampling rate. In the following example, the + # rate maximum is expected to be at 5.785s. + # See PR#453 https://github.com/NeuralEnsemble/elephant/pull/453 + spike_times = np.array( + [4.45, 4.895, 5.34, 5.785, 6.23, 6.675, 7.12]) * pq.s + # add 0.01 s + shifted_spike_times = spike_times + .01 * pq.s + + spiketrain = neo.SpikeTrain(shifted_spike_times, + t_start=0, + t_stop=10) + kernel = kernels.GaussianKernel(sigma=500 * pq.ms) + sampling_period = 445 * pq.ms + rate = statistics.instantaneous_rate( + spiketrain, + sampling_period=sampling_period, + kernel=kernel, center_kernel=True, trim=False) + self.assertAlmostEqual(spike_times[3].magnitude.item(), + rate.times[rate.argmax()].magnitude.item()) + + def test_instantaneous_rate_border_correction(self): + np.random.seed(0) + n_spiketrains = 125 + rate = 50. * pq.Hz + t_start = 0. * pq.ms + t_stop = 1000. * pq.ms + + sampling_period = 0.1 * pq.ms + + trial_list = StationaryPoissonProcess( + rate=rate, t_start=t_start, t_stop=t_stop + ).generate_n_spiketrains(n_spiketrains) + + for correction in (True, False): + rates = [] + for trial in trial_list: + # calculate the instantaneous rate, discard extra dimension + instantaneous_rate = statistics.instantaneous_rate( + spiketrains=trial, + sampling_period=sampling_period, + kernel='auto', + border_correction=correction + ) + rates.append(instantaneous_rate) # The average estimated rate gives the average estimated value of # the firing rate in each time bin. From 72030b7919cc203c24de056c4066dd920b8067d3 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 30 Mar 2022 18:40:30 +0200 Subject: [PATCH 50/63] This is housekeeping in preparation of a release 0.11.0 (#452) * update copyright year to 2022 * fix PyPI description display and updated copyright year in `LICENSE.txt` * Bumped version number * clear outputs of gpfa notebook * fix pep8 * fix further pep8 * fixed CodeFactor issues * fixed further CodeFactor issues * removed maintainers_guide.rst * remove travis.yml * added release notes for release 0.11.0 --- .travis.yml | 76 --------- LICENSE.txt | 4 +- README.md | 2 +- doc/conf.py | 1 - doc/maintainers_guide.rst | 146 ------------------ doc/release_notes.rst | 59 +++++++ doc/tutorials/gpfa.ipynb | 48 +++--- elephant/VERSION | 2 +- elephant/__init__.py | 2 +- elephant/causality/granger.py | 2 +- elephant/conversion.py | 2 +- elephant/cubic.py | 2 +- elephant/gpfa/gpfa.py | 2 +- elephant/gpfa/gpfa_core.py | 2 +- elephant/gpfa/gpfa_util.py | 2 +- elephant/kernels.py | 2 +- elephant/neo_tools.py | 2 +- elephant/pandas_bridge.py | 2 +- elephant/parallel/__init__.py | 2 +- elephant/phase_analysis.py | 2 +- elephant/signal_processing.py | 19 ++- elephant/spade.py | 2 +- elephant/spectral.py | 6 +- elephant/spike_train_correlation.py | 2 +- elephant/spike_train_dissimilarity.py | 2 +- elephant/spike_train_generation.py | 2 +- elephant/spike_train_surrogates.py | 2 +- elephant/spike_train_synchrony.py | 2 +- elephant/sta.py | 2 +- elephant/statistics.py | 2 +- elephant/test/test_asset.py | 2 +- elephant/test/test_causality.py | 2 +- elephant/test/test_conversion.py | 2 +- elephant/test/test_cubic.py | 2 +- elephant/test/test_gpfa.py | 3 +- elephant/test/test_kernels.py | 2 +- elephant/test/test_neo_tools.py | 2 +- elephant/test/test_pandas_bridge.py | 3 +- elephant/test/test_phase_analysis.py | 2 +- elephant/test/test_signal_processing.py | 10 +- elephant/test/test_spade.py | 50 +++--- elephant/test/test_spectral.py | 24 +-- elephant/test/test_spike_train_correlation.py | 4 +- .../test/test_spike_train_dissimilarity.py | 120 +++++++------- elephant/test/test_spike_train_generation.py | 42 +++-- elephant/test/test_spike_train_surrogates.py | 60 +++---- elephant/test/test_sta.py | 15 +- elephant/test/test_statistics.py | 42 +++-- elephant/test/test_unitary_event_analysis.py | 2 +- elephant/test/test_waveform_features.py | 2 +- elephant/unitary_event_analysis.py | 6 +- elephant/waveform_features.py | 2 +- setup.py | 1 + 53 files changed, 324 insertions(+), 479 deletions(-) delete mode 100644 .travis.yml delete mode 100644 doc/maintainers_guide.rst diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index ddfb4bcfe..000000000 --- a/.travis.yml +++ /dev/null @@ -1,76 +0,0 @@ -dist: bionic -language: python -sudo: false - -addons: - apt: - update: true - -matrix: - include: - - name: "conda 3.7 extras,opencl" - python: 3.7 - env: DISTRIB="conda" - before_install: sudo apt install -y libopenmpi-dev openmpi-bin - before_script: - - conda install -c conda-forge pyopencl oclgrind clang=9.0.1 - - pip install -r requirements/requirements-extras.txt - - pip install mpi4py - script: mpiexec -n 1 python -m mpi4py.futures -m pytest --cov=elephant --import-mode=importlib - after_success: coveralls || echo "coveralls failed" - - - name: "conda 3.7" - python: 3.7 - env: DISTRIB="conda" - - - name: "conda 3.8" - python: 3.8 - env: DISTRIB="conda" - - - name: "pip 3.9" - python: 3.9 - env: DISTRIB="pip" - - - name: "docs" - python: 3.7 - env: DISTRIB="conda" - before_install: sudo apt install -y libopenmpi-dev openmpi-bin - before_script: - - conda install -c conda-forge pandoc - - pip install -r requirements/requirements-docs.txt - - pip install -r requirements/requirements-tutorials.txt - - pip install -r requirements/requirements-extras.txt - - pip install mpi4py - - pip install viziphant # remove viziphant, once integrated into requirements-tutorials.txt - - sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py - script: cd doc && make html - -install: - - if [[ "${DISTRIB}" == "conda" ]]; - then - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh; - bash miniconda.sh -b -p $HOME/miniconda; - source "$HOME/miniconda/etc/profile.d/conda.sh"; - conda config --set always_yes yes; - conda update conda; - sed -i "s/python>=[0-9]\.[0-9]/python=${TRAVIS_PYTHON_VERSION}/g" requirements/environment.yml; - sed -i '/mpi4py/d' requirements/environment.yml; - conda env create -f requirements/environment.yml; - conda activate elephant; - conda list; - else - pip install -r requirements/requirements.txt; - fi - - - pip -V - - pip install -r requirements/requirements-tests.txt - - pip install pytest==6.2.5 # hotfix as pytest 7.0.0 breaks CI workflows with --import-mode=importlib - - pip install pytest-cov coveralls - - pip install . - - python -c "import sys; sys.path.remove(''); import elephant; print(elephant.__file__, elephant.__version__)" - - python -c "import sys; sys.path.remove(''); from elephant.spade import HAVE_FIM; assert HAVE_FIM" - - pip list - - python --version - -script: - pytest --cov=elephant --import-mode=importlib diff --git a/LICENSE.txt b/LICENSE.txt index b55a3fb80..ef8aebaf3 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,4 +1,4 @@ -Copyright (c) 2014-2019, Elephant authors and contributors +Copyright (c) 2014-2022, Elephant authors and contributors All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -7,4 +7,4 @@ Redistribution and use in source and binary forms, with or without modification, * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the names of the copyright holders nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/README.md b/README.md index b7a9971e1..8516b9810 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ Modified BSD License, see [LICENSE.txt](LICENSE.txt) for details. #### Copyright -:copyright: 2014-2021 by the [Elephant team](doc/authors.rst). +:copyright: 2014-2022 by the [Elephant team](doc/authors.rst). #### Acknowledgments diff --git a/doc/conf.py b/doc/conf.py index bb7b338ec..d77f26acd 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -89,7 +89,6 @@ exclude_patterns = [ '_build', '**.ipynb_checkpoints', - 'maintainers_guide.rst', # should not be visible for users ] # The reST default role (used for this markup: `text`) to use for all documents. diff --git a/doc/maintainers_guide.rst b/doc/maintainers_guide.rst deleted file mode 100644 index a05db9e73..000000000 --- a/doc/maintainers_guide.rst +++ /dev/null @@ -1,146 +0,0 @@ -================= -Maintainers guide -================= - -This guide is for Elephant maintainers only. - - -Python 3 --------- - -Backward compatibility is achieved by putting a few future imports at the -beginning of each source file: - -.. code-block:: python - - from __future__ import division, print_function, unicode_literals - -All code should conform as much as possible to -`PEP 8 `_. - -Each source file should have a copyright and a license note. - - -Structure of the doc/ folder ----------------------------- - -Documentation in Elephant is written exclusively using the ``sphinx`` package -and resides in the ``doc`` folder, in addition to the docstrings contained of -the ``elephant`` modules. In the following, we outline the main components of -the Elephant documentation. - - -Top-level documentation -~~~~~~~~~~~~~~~~~~~~~~~ - -General information about the Elephant package and a gentle introduction are -contained in various ``.rst`` files in the top-level directory of the Elephant -package. Here, :file:`index.rst` is the central starting point, and the hierarchical -document structure is specified using the ``toctree`` directives. In particular, -these files contain a general introduction and tutorial on Elephant, the -release notes of Elephant versions, and this development guide. - - -Module and function reference -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -All modules in Elephant are semi-automatically documented. To this end, for -each module ``x`` a file ``doc/reference/x.rst`` exists with the following -contents: - -.. code:: rst - - ============================ - `x` - Short descriptive name - ============================ - - .. automodule:: elephant.x - -This instructs Sphinx to add the module documentation in the module docstring -into the file. - -The module docstring of ``elephant/x.py`` is also standardized in its structure: - -.. code:: rst - - .. include:: x-overview.rst - - .. current_module elephant.x - - Overview of Functions - --------------------- - - <> - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - .. autosummary:: - :toctree: toctree/x/ - - function1 - function2 - - <> - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - .. autosummary:: - :toctree: toctree/x/ - - function3 - function4 - - -Each module documentation starts with a short, understandable introduction to -the functionality of the module, the "Overview". This text is written in a -separate file residing in `doc/reference/x-overview.rst`, and is included on -the first line. This keeps the docstring in the code short. - -Next, we specify the current module as `x`, in order to avoid confusion if -a module uses submodules. - -In the following, all functions of the module are listed in an order that is -intuitive for users. Where it makes sense, these functions can be thematically -grouped using third-level headings. For small modules, no such headings are -needed. - - - -Making a release ----------------- - -1. Increment the Elephant package version in :file:`elephant/VERSION`. - -2. Add a section in :file:`doc/release_notes.rst`, describing in short the - changes made from the previous release. - -3. Check that the copyright statement (in :file:`LICENSE.txt`, - :file:`README.md`, and :file:`doc/conf.py`) is correct. - -4. If there is a new module do not forget to add the module name to the - :file:`doc/modules.rst` and make a file with a short description in - :file:`doc/reference/.rst`. - -5. Push the commit with release notes and version updated to github. - -6. Remove :file:`elephant/spade_src/fim.so`. Otherwise, it'll be included in - the built package (it should be downloaded at pip install). - -7. Build a source package and upload it to PyPi. - - Build a source package (see `Packaging Python Projects - `_):: - - $ pip install --user --upgrade twine - $ python setup.py sdist - - To upload the package to `PyPI `_ - (if you have the necessary permissions):: - - $ python -m twine upload dist/elephant-X.Y.Z.tar.gz - -8. Finally, make a release on GitHub UI page and copy-paste the release notes. - Then tag the release in the Git repository and push it:: - - $ git tag - $ git push --tags upstream - - Here, version should be of the form ``vX.Y.Z``. diff --git a/doc/release_notes.rst b/doc/release_notes.rst index 8b7cf226a..f37be2b90 100644 --- a/doc/release_notes.rst +++ b/doc/release_notes.rst @@ -2,6 +2,65 @@ Release Notes ============= +Elephant 0.11.0 release notes +============================= + +Breaking changes +------------- + +* For current source density measures electrode coordinates can no longer be supplied via a `RecordingChannelGroup` object as it is no longer supported in Neo v0.10.0 (#447) + +New functionality and features +------------- + +* Redesigned `elephant.spike_train_generation` module using classes (old API is retained for compatibility) (#416) +* Added function to calculate the multitaper power spectral density estimate in `elephant.spectral` (#417) +* Added a boundary correction for the firing rate estimator `elephant.statistics.instantaneous_rate` with Gaussian kernels (#414) +* Function to discretise spiketimes for a given spiketrain in `elephant.conversion` (#454) +* Support for the new `SpikeTrainList` object of Neo (#447) + +Bug fixes +------------- + +* Issue with unit scaling in `BinnedSpikeTrain` (#425) +* Changed `BinnedSpikeTrain` to support quantities<0.12.4 (#418) +* Fix `FloatingPointError` in ICSD (#421) +* `t_start` information was lost while transposing LFP for `current_source_density` module (#432) +* Fix `neo_tools` unit tests to work with Neo 0.10.0+ (#446) +* Fixed various issues with consistency of bin boundaries of instantaneous rates (#453) + +Documentation +------------- + +* Update tutorials ASSET and UE tutorial and datasets to use nixio >=1.5.0 (#441) +* Updated `spade` tutorial to work with viziphant 0.2.0 (#444) +* Fixed figures in the Granger causality tutorial (#434) +* Add DOIs to documentation (#456) +* Fixed random seed selection in some tutorials (#430) + +Optimizations +------------- + +* Highly optimized run-time of the SPADE analysis (#419) +* More efficient storage of spike complexities by the `elephant.statistics.Complexity` class (#412) +* Updated `elephant.signal_processing.zscore` function for in-place operations (#440) + +Other changes +------------- + +* Continuous Integration (CI) was moved to github actions (#451) +* Change test framework from Nose to pytest (#413) +* Added DOI with zenodo (#445) +* Versioning for associated `elephant-data` repository for example datasets introduced (#463) + + +Selected dependency changes +------------- +* nixio >= 1.5.0 +* neo >= 0.10.0 +* python >= 3.7 + + Elephant 0.10.0 release notes ============================= diff --git a/doc/tutorials/gpfa.ipynb b/doc/tutorials/gpfa.ipynb index 268b64df2..4862fe692 100644 --- a/doc/tutorials/gpfa.ipynb +++ b/doc/tutorials/gpfa.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "code_folding": [ 12, @@ -240,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -284,6 +284,7 @@ }, { "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [ @@ -356,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -381,20 +382,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initializing parameters using factor analysis...\n", - "\n", - "Fitting GPFA model...\n", - "dict_keys(['covType', 'gamma', 'eps', 'd', 'C', 'R', 'notes'])\n" - ] - } - ], + "outputs": [], "source": [ "gpfa_2dim.fit(spiketrains_oscillator[:num_trials//2])\n", "print(gpfa_2dim.params_estimated.keys())" @@ -409,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -425,6 +415,7 @@ }, { "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ @@ -486,6 +477,7 @@ }, { "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ @@ -562,7 +554,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -609,6 +601,7 @@ }, { "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [ @@ -691,6 +684,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, + "outputs": [ { "name": "stdout", @@ -881,11 +875,28 @@ "\n", "[3] Viswanath, D (2004) The fractal property of the Lorenz attractor. Physica D 190(1-2):115-128." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(scipy.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { + "display_name": "inm-elephant", "language": "python", "name": "inm-elephant" @@ -900,6 +911,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", + "version": "3.8.10" }, "nbsphinx": { diff --git a/elephant/VERSION b/elephant/VERSION index 71172b43a..142464bf2 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.10.1 \ No newline at end of file +0.11.0 \ No newline at end of file diff --git a/elephant/__init__.py b/elephant/__init__.py index 4795583b6..c91acf8d3 100644 --- a/elephant/__init__.py +++ b/elephant/__init__.py @@ -2,7 +2,7 @@ """ Elephant is a package for the analysis of neurophysiology data, based on Neo. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/causality/granger.py b/elephant/causality/granger.py index 7a1b184e6..5c6311200 100644 --- a/elephant/causality/granger.py +++ b/elephant/causality/granger.py @@ -55,7 +55,7 @@ :target: https://mybinder.org/v2/gh/NeuralEnsemble/elephant/master ?filepath=doc/tutorials/granger_causality.ipynb -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/conversion.py b/elephant/conversion.py index adb070865..0c0cf3857 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -70,7 +70,7 @@ BinnedSpikeTrain(t_start=0.0 ms, t_stop=9000.0 ms, bin_size=1000.0 ms; shape=(2, 9)) -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ diff --git a/elephant/cubic.py b/elephant/cubic.py index 9aec56164..e94839cae 100644 --- a/elephant/cubic.py +++ b/elephant/cubic.py @@ -39,7 +39,7 @@ >>> kappa [20.1, 22.656565656565657, 27.674706246134818] -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ diff --git a/elephant/gpfa/gpfa.py b/elephant/gpfa/gpfa.py index 17a13a384..85681172d 100644 --- a/elephant/gpfa/gpfa.py +++ b/elephant/gpfa/gpfa.py @@ -64,7 +64,7 @@ The original MATLAB code is available at Byron Yu's website: https://users.ece.cmu.edu/~byronyu/software.shtml -:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2022 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/gpfa/gpfa_core.py b/elephant/gpfa/gpfa_core.py index 5b8021986..f4f010380 100644 --- a/elephant/gpfa/gpfa_core.py +++ b/elephant/gpfa/gpfa_core.py @@ -2,7 +2,7 @@ """ GPFA core functionality. -:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2022 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/gpfa/gpfa_util.py b/elephant/gpfa/gpfa_util.py index 05deccab9..97aa6105c 100644 --- a/elephant/gpfa/gpfa_util.py +++ b/elephant/gpfa/gpfa_util.py @@ -2,7 +2,7 @@ """ GPFA util functions. -:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2022 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/kernels.py b/elephant/kernels.py index 27fa41582..1f3739db2 100644 --- a/elephant/kernels.py +++ b/elephant/kernels.py @@ -67,7 +67,7 @@ >>> kernel.icdf(0.5) array(1.18677054) * s -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/neo_tools.py b/elephant/neo_tools.py index b0e11f9bb..73306f5e1 100644 --- a/elephant/neo_tools.py +++ b/elephant/neo_tools.py @@ -10,7 +10,7 @@ get_all_events get_all_epochs -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/pandas_bridge.py b/elephant/pandas_bridge.py index ff400d055..1ffb3ea21 100644 --- a/elephant/pandas_bridge.py +++ b/elephant/pandas_bridge.py @@ -13,7 +13,7 @@ multi_epochs_to_dataframe slice_spiketrain -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/parallel/__init__.py b/elephant/parallel/__init__.py index 6395eea6c..d2ae08194 100644 --- a/elephant/parallel/__init__.py +++ b/elephant/parallel/__init__.py @@ -32,7 +32,7 @@ MPICommExecutor -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/phase_analysis.py b/elephant/phase_analysis.py index 7c797e58d..ce0d7d9cf 100644 --- a/elephant/phase_analysis.py +++ b/elephant/phase_analysis.py @@ -10,7 +10,7 @@ mean_phase_vector phase_difference -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/signal_processing.py b/elephant/signal_processing.py index bab1aad00..dbcfb7293 100644 --- a/elephant/signal_processing.py +++ b/elephant/signal_processing.py @@ -14,7 +14,7 @@ rauc derivative -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -553,10 +553,10 @@ def butter(signal, highpass_frequency=None, lowpass_frequency=None, order=4, # https://github.com/NeuralEnsemble/python-neo/issues/752 signal_out.array_annotate(**signal.array_annotations) return signal_out - elif isinstance(signal, pq.quantity.Quantity): + if isinstance(signal, pq.quantity.Quantity): return filtered_data * signal.units - else: - return filtered_data + + return filtered_data @deprecated_alias(nco='n_cycles', freq='frequency', fs='sampling_frequency') @@ -978,12 +978,11 @@ def rauc(signal, baseline=None, bin_duration=None, t_start=None, t_stop=None): # return a single value for each channel return rauc.squeeze() - else: - # return an AnalogSignal with times corresponding to center of each bin - t_start = signal.t_start.rescale(bin_duration.units) + bin_duration / 2 - rauc_sig = neo.AnalogSignal(rauc, t_start=t_start, - sampling_period=bin_duration) - return rauc_sig + # return an AnalogSignal with times corresponding to center of each bin + t_start = signal.t_start.rescale(bin_duration.units) + bin_duration / 2 + rauc_sig = neo.AnalogSignal(rauc, t_start=t_start, + sampling_period=bin_duration) + return rauc_sig def derivative(signal): diff --git a/elephant/spade.py b/elephant/spade.py index 6f95e55cc..8ad93d190 100644 --- a/elephant/spade.py +++ b/elephant/spade.py @@ -84,7 +84,7 @@ Refer to Viziphant documentation to check how to visualzie such patterns. -:copyright: Copyright 2014-2021 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals diff --git a/elephant/spectral.py b/elephant/spectral.py index 661cac76e..1fe68ec32 100644 --- a/elephant/spectral.py +++ b/elephant/spectral.py @@ -9,7 +9,7 @@ welch_psd welch_coherence -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -710,13 +710,13 @@ def welch_coherence(signal_i, signal_j, n_segments=8, len_segment=None, elif len_segment is not None: if len_segment <= 0: raise ValueError("len_seg must be a positive number") - elif xdata.shape[axis] < len_segment: + if xdata.shape[axis] < len_segment: raise ValueError("len_seg must be shorter than the data length") nperseg = len_segment else: if n_segments <= 0: raise ValueError("n_segments must be a positive number") - elif xdata.shape[axis] < n_segments: + if xdata.shape[axis] < n_segments: raise ValueError("n_segments must be smaller than the data length") # when only *n_segments* is given, *nperseg* is determined by solving # the following equation: diff --git a/elephant/spike_train_correlation.py b/elephant/spike_train_correlation.py index 3f5d21736..8ba37b69c 100644 --- a/elephant/spike_train_correlation.py +++ b/elephant/spike_train_correlation.py @@ -11,7 +11,7 @@ spike_time_tiling_coefficient spike_train_timescale -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals diff --git a/elephant/spike_train_dissimilarity.py b/elephant/spike_train_dissimilarity.py index 9fcd4e458..100b52fe8 100644 --- a/elephant/spike_train_dissimilarity.py +++ b/elephant/spike_train_dissimilarity.py @@ -16,7 +16,7 @@ victor_purpura_distance van_rossum_distance -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/spike_train_generation.py b/elephant/spike_train_generation.py index 5fd63e315..47b300f6e 100644 --- a/elephant/spike_train_generation.py +++ b/elephant/spike_train_generation.py @@ -47,7 +47,7 @@ :style: unsrt -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/spike_train_surrogates.py b/elephant/spike_train_surrogates.py index ba7a0737f..6a1acbec5 100644 --- a/elephant/spike_train_surrogates.py +++ b/elephant/spike_train_surrogates.py @@ -28,7 +28,7 @@ bin_shuffling trial_shifting -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/spike_train_synchrony.py b/elephant/spike_train_synchrony.py index 8cde2d758..f8e438527 100644 --- a/elephant/spike_train_synchrony.py +++ b/elephant/spike_train_synchrony.py @@ -13,7 +13,7 @@ Synchrotool -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function, unicode_literals diff --git a/elephant/sta.py b/elephant/sta.py index 0bb5dbc3c..fc9c4e0c5 100644 --- a/elephant/sta.py +++ b/elephant/sta.py @@ -9,7 +9,7 @@ spike_triggered_average spike_field_coherence -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/statistics.py b/elephant/statistics.py index 314c3215c..922a2cdc1 100644 --- a/elephant/statistics.py +++ b/elephant/statistics.py @@ -60,7 +60,7 @@ :style: unsrt -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_asset.py b/elephant/test/test_asset.py index b6a38f9c1..0962c5844 100644 --- a/elephant/test/test_asset.py +++ b/elephant/test/test_asset.py @@ -2,7 +2,7 @@ """ Unit tests for the ASSET analysis. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_causality.py b/elephant/test/test_causality.py index b1238e268..398274db6 100644 --- a/elephant/test/test_causality.py +++ b/elephant/test/test_causality.py @@ -2,7 +2,7 @@ """ Unit tests for the causality module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function diff --git a/elephant/test/test_conversion.py b/elephant/test/test_conversion.py index e63d6690d..24f1dfce7 100644 --- a/elephant/test/test_conversion.py +++ b/elephant/test/test_conversion.py @@ -2,7 +2,7 @@ """ Unit tests for the conversion module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_cubic.py b/elephant/test/test_cubic.py index ee077ad5e..37750a708 100644 --- a/elephant/test/test_cubic.py +++ b/elephant/test/test_cubic.py @@ -2,7 +2,7 @@ """ Unit tests for the CUBIC analysis. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_gpfa.py b/elephant/test/test_gpfa.py index e6969367b..19d35ae31 100644 --- a/elephant/test/test_gpfa.py +++ b/elephant/test/test_gpfa.py @@ -2,7 +2,7 @@ """ Unit tests for the GPFA analysis. -:copyright: Copyright 2014-2020 by the Elephant team, see AUTHORS.txt. +:copyright: Copyright 2014-2022 by the Elephant team, see AUTHORS.txt. :license: Modified BSD, see LICENSE.txt for details. """ @@ -20,6 +20,7 @@ from elephant.gpfa import gpfa_util from elephant.gpfa import GPFA from sklearn.model_selection import cross_val_score + HAVE_SKLEARN = True except ImportError: HAVE_SKLEARN = False diff --git a/elephant/test/test_kernels.py b/elephant/test/test_kernels.py index 90577479a..f195a9534 100644 --- a/elephant/test/test_kernels.py +++ b/elephant/test/test_kernels.py @@ -2,7 +2,7 @@ """ Unit tests for the kernels module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_neo_tools.py b/elephant/test/test_neo_tools.py index b3e262f48..eb3f14084 100644 --- a/elephant/test/test_neo_tools.py +++ b/elephant/test/test_neo_tools.py @@ -2,7 +2,7 @@ """ Unit tests for the neo_tools module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ import random diff --git a/elephant/test/test_pandas_bridge.py b/elephant/test/test_pandas_bridge.py index 78cd71635..ff2c37df6 100644 --- a/elephant/test/test_pandas_bridge.py +++ b/elephant/test/test_pandas_bridge.py @@ -2,7 +2,7 @@ """ Unit tests for the pandas bridge module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -27,6 +27,7 @@ pandas_version = StrictVersion('0.0.0') else: import elephant.pandas_bridge as ep + HAVE_PANDAS = True pandas_version = StrictVersion(pd.__version__) diff --git a/elephant/test/test_phase_analysis.py b/elephant/test/test_phase_analysis.py index ea996a3ae..0b3db3d57 100644 --- a/elephant/test/test_phase_analysis.py +++ b/elephant/test/test_phase_analysis.py @@ -2,7 +2,7 @@ """ Unit tests for the phase analysis module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function diff --git a/elephant/test/test_signal_processing.py b/elephant/test/test_signal_processing.py index a139f9bb2..8b648cf63 100644 --- a/elephant/test/test_signal_processing.py +++ b/elephant/test/test_signal_processing.py @@ -2,7 +2,7 @@ """ Unit tests for the signal_processing module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division, print_function @@ -664,7 +664,6 @@ def test_hilbert_theoretical_long_signals(self): """ # Performing test using all pad types for padding in ['nextpow', 'none', 16384]: - h = elephant.signal_processing.hilbert( self.long_signals, padding=padding) @@ -692,7 +691,7 @@ def test_hilbert_theoretical_long_signals(self): # amplitude amplitudediff = \ amplitude[ind1:ind2, :] - self.amplitude[ind1:ind2, :] -# + # assert_allclose(phasediff, 0, atol=0.1) assert_allclose(amplitudediff, 0, atol=0.5) @@ -710,7 +709,6 @@ def test_hilbert_theoretical_one_period(self): # Performing test using both pad types for padding in ['nextpow', 'none', 512]: - h = elephant.signal_processing.hilbert( self.one_period, padding=padding) @@ -1094,8 +1092,8 @@ def test_rauc_times_without_overextending_bin(self): def test_rauc_times_with_overextending_bin(self): """Test rauc returns correct times when signal is NOT binned evenly""" - - bin_duration = 0.99 * pq.s # results in one bin center > original t_stop + # results in one bin center > original t_stop + bin_duration = 0.99 * pq.s rauc_arr = elephant.signal_processing.rauc( self.test_signal1, bin_duration=bin_duration) self.assertTrue(isinstance(rauc_arr, neo.AnalogSignal)) diff --git a/elephant/test/test_spade.py b/elephant/test/test_spade.py index 3736b330d..2b4c104ff 100644 --- a/elephant/test/test_spade.py +++ b/elephant/test/test_spade.py @@ -1,7 +1,7 @@ """ Unit tests for the spade module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division @@ -20,6 +20,7 @@ try: import statsmodels + HAVE_STATSMODELS = True except ImportError: HAVE_STATSMODELS = False @@ -335,8 +336,9 @@ def test_fpgrowth_fca(self): mining_results_fpg = spade._fpgrowth( transactions, rel_matrix=rel_matrix) - print('#################################################################') - print('mining results fpg',mining_results_fpg) + print( + '################################################################') + print('mining results fpg', mining_results_fpg) # mining the data with C fim mining_results_ffca = spade._fast_fca(context) @@ -468,92 +470,92 @@ def test_spade_raise_error(self): TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4.1, stat_corr='no') + bin_size=1. * pq.ms, winlen=4.1, stat_corr='no') # Test min_spikes not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, min_spikes=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, min_spikes=3.4, stat_corr='no') # Test min_occ not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, min_occ=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, min_occ=3.4, stat_corr='no') # Test max_spikes not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, max_spikes=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, max_spikes=3.4, stat_corr='no') # Test max_occ not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, max_occ=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, max_occ=3.4, stat_corr='no') # Test min_neu not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, min_neu=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, min_neu=3.4, stat_corr='no') # Test wrong stability params self.assertRaises( ValueError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, approx_stab_pars={'wrong key': 0}, + bin_size=1. * pq.ms, winlen=4, approx_stab_pars={'wrong key': 0}, stat_corr='no') # Test n_surr not int self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=3.4, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, n_surr=3.4, stat_corr='no') # Test dither not pq.Quantity self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha=0.05, + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha=0.05, dither=15., stat_corr='no') # Test wrong alpha self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha='5 %', - dither=15.*pq.ms, stat_corr='no') + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha='5 %', + dither=15. * pq.ms, stat_corr='no') # Test wrong statistical correction self.assertRaises( ValueError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha=0.05, - dither=15.*pq.ms, stat_corr='wrong correction') + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha=0.05, + dither=15. * pq.ms, stat_corr='wrong correction') # Test wrong psr_params self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha=0.05, - dither=15.*pq.ms, stat_corr='no', psr_param=(2.5, 3.4, 2.1)) + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha=0.05, + dither=15. * pq.ms, stat_corr='no', psr_param=(2.5, 3.4, 2.1)) # Test wrong psr_params self.assertRaises( TypeError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha=0.05, - dither=15.*pq.ms, stat_corr='no', psr_param=3.1) + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha=0.05, + dither=15. * pq.ms, stat_corr='no', psr_param=3.1) # Test output format self.assertRaises( ValueError, spade.spade, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - bin_size=1.*pq.ms, winlen=4, n_surr=100, alpha=0.05, - dither=15.*pq.ms, stat_corr='no', output_format='wrong_output') + bin_size=1. * pq.ms, winlen=4, n_surr=100, alpha=0.05, + dither=15. * pq.ms, stat_corr='no', output_format='wrong_output') # Test wrong spectrum parameter self.assertRaises( ValueError, spade.spade, @@ -570,7 +572,7 @@ def test_spade_raise_error(self): ValueError, spade.pvalue_spectrum, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=6 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=6 * pq.s)], - 1 * pq.ms, 4, dither=10*pq.ms, n_surr=1, + 1 * pq.ms, 4, dither=10 * pq.ms, n_surr=1, spectrum='invalid_key') # Test negative minimum number of spikes self.assertRaises( @@ -589,7 +591,7 @@ def test_spade_raise_error(self): ValueError, spade.pvalue_spectrum, [neo.SpikeTrain([1, 2, 3] * pq.s, t_stop=5 * pq.s), neo.SpikeTrain([3, 4, 5] * pq.s, t_stop=5 * pq.s)], - 1 * pq.ms, 4, dither=10*pq.ms, n_surr=100, + 1 * pq.ms, 4, dither=10 * pq.ms, n_surr=100, surr_method='invalid_key') # Test negative number of surrogates self.assertRaises( diff --git a/elephant/test/test_spectral.py b/elephant/test/test_spectral.py index 83659d809..06ed01e65 100644 --- a/elephant/test/test_spectral.py +++ b/elephant/test/test_spectral.py @@ -2,7 +2,7 @@ """ Unit tests for the spectral module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -88,7 +88,7 @@ def test_welch_psd_behavior(self): noverlap=0, **{key: val}) self.assertTrue( (freqs == freqs_spsig).all() and ( - psd == psd_spsig).all()) + psd == psd_spsig).all()) # - generate multidimensional data for check of parameter `axis` num_channel = 4 @@ -126,10 +126,10 @@ def test_welch_psd_input_types(self): # check if the results from different input types are identical self.assertTrue( (freqs_neo == freqs_pq).all() and ( - psd_neo == psd_pq).all()) + psd_neo == psd_pq).all()) self.assertTrue( (freqs_neo == freqs_np).all() and ( - psd_neo == psd_np).all()) + psd_neo == psd_np).all()) def test_welch_psd_multidim_input(self): # generate multidimensional data @@ -373,7 +373,7 @@ def test_welch_cohere_behavior(self): places=2) self.assertAlmostEqual(phase_lag[coherency.argmax()], -np.pi / 2, places=2) - freqs_np, coherency_np, phase_lag_np =\ + freqs_np, coherency_np, phase_lag_np = \ elephant.spectral.welch_coherence(x.magnitude.flatten(), y.magnitude.flatten(), fs=1 / sampling_period, @@ -387,7 +387,7 @@ def test_welch_cohere_behavior(self): data_length = 5000 x_multidim = np.random.normal(size=(num_channel, data_length)) y_multidim = np.random.normal(size=(num_channel, data_length)) - freqs, coherency, phase_lag =\ + freqs, coherency, phase_lag = \ elephant.spectral.welch_coherence(x_multidim, y_multidim) freqs_T, coherency_T, phase_lag_T = elephant.spectral.welch_coherence( x_multidim.T, y_multidim.T, axis=0) @@ -407,13 +407,13 @@ def test_welch_cohere_input_types(self): # outputs from AnalogSignal input are of Quantity type # (standard usage) - freqs_neo, coherency_neo, phase_lag_neo =\ + freqs_neo, coherency_neo, phase_lag_neo = \ elephant.spectral.welch_coherence(x, y) self.assertTrue(isinstance(freqs_neo, pq.quantity.Quantity)) self.assertTrue(isinstance(phase_lag_neo, pq.quantity.Quantity)) # outputs from Quantity array input are of Quantity type - freqs_pq, coherency_pq, phase_lag_pq = elephant.spectral\ + freqs_pq, coherency_pq, phase_lag_pq = elephant.spectral \ .welch_coherence(x.magnitude.flatten() * x.units, y.magnitude.flatten() * y.units, fs=1 / sampling_period) @@ -421,7 +421,7 @@ def test_welch_cohere_input_types(self): self.assertTrue(isinstance(phase_lag_pq, pq.quantity.Quantity)) # outputs from Numpy ndarray input are NOT of Quantity type - freqs_np, coherency_np, phase_lag_np = elephant.spectral\ + freqs_np, coherency_np, phase_lag_np = elephant.spectral \ .welch_coherence(x.magnitude.flatten(), y.magnitude.flatten(), fs=1 / sampling_period) @@ -456,11 +456,11 @@ def test_welch_cohere_multidim_input(self): sampling_period=sampling_period * pq.s) # check if the results from different input types are identical - freqs_np, coherency_np, phase_lag_np = elephant.spectral\ + freqs_np, coherency_np, phase_lag_np = elephant.spectral \ .welch_coherence(x_np, y_np, fs=1 / sampling_period) - freqs_neo, coherency_neo, phase_lag_neo =\ + freqs_neo, coherency_neo, phase_lag_neo = \ elephant.spectral.welch_coherence(x_neo, y_neo) - freqs_neo_1dim, coherency_neo_1dim, phase_lag_neo_1dim =\ + freqs_neo_1dim, coherency_neo_1dim, phase_lag_neo_1dim = \ elephant.spectral.welch_coherence(x_neo_1dim, y_neo_1dim) self.assertTrue(np.all(freqs_np == freqs_neo)) self.assertTrue(np.all(coherency_np.T == coherency_neo)) diff --git a/elephant/test/test_spike_train_correlation.py b/elephant/test/test_spike_train_correlation.py index 8b30fe505..49f6a5728 100644 --- a/elephant/test/test_spike_train_correlation.py +++ b/elephant/test/test_spike_train_correlation.py @@ -2,7 +2,7 @@ """ Unit tests for the spike_train_correlation module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -15,7 +15,7 @@ import elephant.conversion as conv import elephant.spike_train_correlation as sc -from elephant.spike_train_generation import homogeneous_poisson_process,\ +from elephant.spike_train_generation import homogeneous_poisson_process, \ homogeneous_gamma_process import math diff --git a/elephant/test/test_spike_train_dissimilarity.py b/elephant/test/test_spike_train_dissimilarity.py index bb990ba01..5632bbbd0 100644 --- a/elephant/test/test_spike_train_dissimilarity.py +++ b/elephant/test/test_spike_train_dissimilarity.py @@ -2,7 +2,7 @@ """ Tests for the spike train dissimilarity measures module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -117,10 +117,10 @@ def test_wrong_input(self): [self.st01, self.st02], self.q1, kernel=kernels.TriangularKernel( 2.0 / (np.sqrt(6.0) * self.q2)))[0, 1], - stds.victor_purpura_distance( - [self.st01, self.st02], self.q3, - kernel=kernels.TriangularKernel( - 2.0 / (np.sqrt(6.0) * self.q2)))[0, 1]) + stds.victor_purpura_distance( + [self.st01, self.st02], self.q3, + kernel=kernels.TriangularKernel( + 2.0 / (np.sqrt(6.0) * self.q2)))[0, 1]) self.assertEqual(stds.victor_purpura_distance( [self.st01, self.st02], kernel=kernels.TriangularKernel( @@ -163,8 +163,8 @@ def test_victor_purpura_distance_fast(self): # Tests on timescales self.assertEqual(stds.victor_purpura_distance( [self.st11, self.st14], self.q1)[0, 1], - stds.victor_purpura_distance( - [self.st11, self.st14], self.q5)[0, 1]) + stds.victor_purpura_distance( + [self.st11, self.st14], self.q5)[0, 1]) self.assertEqual(stds.victor_purpura_distance( [self.st07, self.st11], self.q0)[0, 1], 6.0) self.assertEqual(stds.victor_purpura_distance( @@ -176,14 +176,14 @@ def test_victor_purpura_distance_fast(self): # Tests on unordered spiketrains self.assertEqual(stds.victor_purpura_distance( [self.st11, self.st13], self.q4)[0, 1], - stds.victor_purpura_distance( - [self.st12, self.st13], self.q4)[0, 1]) + stds.victor_purpura_distance( + [self.st12, self.st13], self.q4)[0, 1]) self.assertNotEqual(stds.victor_purpura_distance( [self.st11, self.st13], self.q4, sort=False)[0, 1], - stds.victor_purpura_distance( - [self.st12, self.st13], self.q4, - sort=False)[0, 1]) + stds.victor_purpura_distance( + [self.st12, self.st13], self.q4, + sort=False)[0, 1]) # Tests on metric properties with random spiketrains # (explicit calculation of second metric axiom in particular case, # because from dist_matrix it is trivial) @@ -197,7 +197,7 @@ def test_victor_purpura_distance_fast(self): assert_array_equal(stds.victor_purpura_distance( [self.st21, self.st22], self.q3), stds.victor_purpura_distance( - [self.st22, self.st21], self.q3)) + [self.st22, self.st21], self.q3)) self.assertLessEqual(dist_matrix[0, 1], dist_matrix[0, 2] + dist_matrix[1, 2]) self.assertLessEqual(dist_matrix[0, 2], @@ -281,9 +281,9 @@ def test_victor_purpura_distance_intuitive(self): self.assertEqual(stds.victor_purpura_distance( [self.st11, self.st14], self.q1, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st11, self.st14], self.q5, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st11, self.st14], self.q5, + algorithm='intuitive')[0, 1]) self.assertEqual(stds.victor_purpura_distance( [self.st07, self.st11], self.q0, algorithm='intuitive')[0, 1], 6.0) @@ -300,15 +300,15 @@ def test_victor_purpura_distance_intuitive(self): self.assertEqual(stds.victor_purpura_distance( [self.st11, self.st13], self.q4, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st12, self.st13], self.q4, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st12, self.st13], self.q4, + algorithm='intuitive')[0, 1]) self.assertNotEqual(stds.victor_purpura_distance( [self.st11, self.st13], self.q4, sort=False, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st12, self.st13], self.q4, - sort=False, algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st12, self.st13], self.q4, + sort=False, algorithm='intuitive')[0, 1]) # Tests on metric properties with random spiketrains # (explicit calculation of second metric axiom in particular case, # because from dist_matrix it is trivial) @@ -324,8 +324,8 @@ def test_victor_purpura_distance_intuitive(self): [self.st21, self.st22], self.q3, algorithm='intuitive'), stds.victor_purpura_distance( - [self.st22, self.st21], self.q3, - algorithm='intuitive')) + [self.st22, self.st21], self.q3, + algorithm='intuitive')) self.assertLessEqual(dist_matrix[0, 1], dist_matrix[0, 2] + dist_matrix[1, 2]) self.assertLessEqual(dist_matrix[0, 2], @@ -336,44 +336,44 @@ def test_victor_purpura_distance_intuitive(self): self.assertAlmostEqual(stds.victor_purpura_distance( [self.st14, self.st16], self.q3, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st15, self.st16], self.q3, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st15, self.st16], self.q3, + algorithm='intuitive')[0, 1]) self.assertAlmostEqual(stds.victor_purpura_distance( [self.st16, self.st14], self.q3, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st16, self.st15], self.q3, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st16, self.st15], self.q3, + algorithm='intuitive')[0, 1]) self.assertEqual(stds.victor_purpura_distance( [self.st01, self.st05], self.q3, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st01, self.st05], self.q7, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st01, self.st05], self.q7, + algorithm='intuitive')[0, 1]) # Tests on algorithmic behaviour for equal spike times self.assertEqual(stds.victor_purpura_distance( [self.st31, self.st34], self.q3, algorithm='intuitive')[0, 1], - 0.8 + 1.0) + 0.8 + 1.0) self.assertEqual(stds.victor_purpura_distance( [self.st31, self.st34], self.q3, algorithm='intuitive')[0, 1], - stds.victor_purpura_distance( - [self.st32, self.st33], self.q3, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st32, self.st33], self.q3, + algorithm='intuitive')[0, 1]) self.assertEqual(stds.victor_purpura_distance( [self.st31, self.st33], self.q3, algorithm='intuitive')[0, 1] * 2.0, - stds.victor_purpura_distance( - [self.st32, self.st34], self.q3, - algorithm='intuitive')[0, 1]) + stds.victor_purpura_distance( + [self.st32, self.st34], self.q3, + algorithm='intuitive')[0, 1]) # Tests on spike train list lengthes smaller than 2 self.assertEqual(stds.victor_purpura_distance( [self.st21], self.q3, algorithm='intuitive')[0, 0], 0) self.assertEqual(len(stds.victor_purpura_distance( - [], self.q3, algorithm='intuitive')), 0) + [], self.q3, algorithm='intuitive')), 0) def test_victor_purpura_algorithm_comparison(self): assert_array_almost_equal( @@ -395,37 +395,37 @@ def test_van_rossum_distance(self): # Tests of distances under elementary spike operations self.assertAlmostEqual(stds.van_rossum_distance( [self.st01, self.st02], self.tau2)[0, 1], - float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( - ((self.st01[0] - self.st02[0]) / - self.tau2).simplified)))))) + float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( + ((self.st01[0] - self.st02[0]) / + self.tau2).simplified)))))) self.assertAlmostEqual(stds.van_rossum_distance( [self.st01, self.st05], self.tau2)[0, 1], - float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( - ((self.st01[0] - self.st05[0]) / - self.tau2).simplified)))))) + float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( + ((self.st01[0] - self.st05[0]) / + self.tau2).simplified)))))) self.assertAlmostEqual(stds.van_rossum_distance( [self.st01, self.st05], self.tau2)[0, 1], - np.sqrt(2.0), 1) + np.sqrt(2.0), 1) self.assertAlmostEqual(stds.van_rossum_distance( [self.st01, self.st06], self.tau2)[0, 1], - np.sqrt(2.0), 20) + np.sqrt(2.0), 20) self.assertAlmostEqual(stds.van_rossum_distance( [self.st00, self.st07], self.tau1)[0, 1], - np.sqrt(0 + 2)) + np.sqrt(0 + 2)) self.assertAlmostEqual(stds.van_rossum_distance( [self.st07, self.st08], self.tau4)[0, 1], - float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( - ((self.st07[0] - self.st08[-1]) / - self.tau4).simplified)))))) + float(np.sqrt(2 * (1.0 - np.exp(-np.absolute( + ((self.st07[0] - self.st08[-1]) / + self.tau4).simplified)))))) f_minus_g_squared = ( (self.t > self.st08[0]) * np.exp( -((self.t - self.st08[0]) / self.tau3).simplified) + (self.t > self.st08[1]) * np.exp( -((self.t - self.st08[1]) / self.tau3).simplified) - (self.t > self.st09[0]) * np.exp( - -((self.t - self.st09[0]) / self.tau3).simplified))**2 + -((self.t - self.st09[0]) / self.tau3).simplified)) ** 2 distance = np.sqrt(2.0 * spint.cumtrapz( - y=f_minus_g_squared, x=self.t.magnitude)[-1] / + y=f_minus_g_squared, x=self.t.magnitude)[-1] / self.tau3.rescale(self.t.units).magnitude) self.assertAlmostEqual(stds.van_rossum_distance( [self.st08, self.st09], self.tau3)[0, 1], distance, 5) @@ -500,14 +500,14 @@ def test_van_rossum_distance(self): stds.van_rossum_distance([self.st01, self.st05], self.tau7)[0, 1]) # Tests on algorithmic behaviour for equal spike times f_minus_g_squared = ( - (self.t > self.st31[0]) * np.exp( + (self.t > self.st31[0]) * np.exp( -((self.t - self.st31[0]) / self.tau3).simplified) - - (self.t > self.st34[0]) * np.exp( + (self.t > self.st34[0]) * np.exp( -((self.t - self.st34[0]) / self.tau3).simplified) - - (self.t > self.st34[1]) * np.exp( - -((self.t - self.st34[1]) / self.tau3).simplified))**2 + (self.t > self.st34[1]) * np.exp( + -((self.t - self.st34[1]) / self.tau3).simplified)) ** 2 distance = np.sqrt(2.0 * spint.cumtrapz( - y=f_minus_g_squared, x=self.t.magnitude)[-1] / + y=f_minus_g_squared, x=self.t.magnitude)[-1] / self.tau3.rescale(self.t.units).magnitude) self.assertAlmostEqual(stds.van_rossum_distance([self.st31, self.st34], self.tau3)[0, 1], diff --git a/elephant/test/test_spike_train_generation.py b/elephant/test/test_spike_train_generation.py index 6a1434a2e..23e2692af 100644 --- a/elephant/test/test_spike_train_generation.py +++ b/elephant/test/test_spike_train_generation.py @@ -2,7 +2,7 @@ """ Unit tests for the spike_train_generation module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -160,7 +160,7 @@ def test_statistics(self): for rate in [123.0 * pq.Hz, 0.123 * pq.kHz]: for t_stop in [2345 * pq.ms, 2.345 * pq.s]: - for refractory_period in (None, 3.*pq.ms): + for refractory_period in (None, 3. * pq.ms): np.random.seed(seed=123456) spiketrain_old = stg.homogeneous_poisson_process( rate, t_stop=t_stop, @@ -204,8 +204,8 @@ def test_statistics(self): else: refractory_period = refractory_period.rescale( t_stop.units).item() - measured_rate = 1./expected_mean_isi.rescale( - t_stop.units).item() + measured_rate = 1. / expected_mean_isi.rescale( + t_stop.units).item() effective_rate = measured_rate / ( 1. - measured_rate * refractory_period) @@ -214,7 +214,7 @@ def test_statistics(self): intervals.rescale(t_stop.units).magnitude, "expon", # args are (loc, scale) - args=(refractory_period, 1./effective_rate), + args=(refractory_period, 1. / effective_rate), alternative='two-sided') self.assertGreater(p, 0.001) self.assertLess(D, 0.12) @@ -293,9 +293,9 @@ def test_effective_rate_refractory_period(self): rate_expected = 10 * pq.Hz refractory_period = 90 * pq.ms # 10 ms of effective ISI spiketrain = stg.StationaryPoissonProcess( - rate_expected, t_stop=1000 * pq.s, - refractory_period=refractory_period - ).generate_spiketrain() + rate_expected, t_stop=1000 * pq.s, + refractory_period=refractory_period + ).generate_spiketrain() rate_obtained = len(spiketrain) / spiketrain.t_stop rate_obtained = rate_obtained.simplified self.assertAlmostEqual(rate_expected.simplified, @@ -339,7 +339,7 @@ def test_statistics(self): a, b, t_stop=t_stop) np.random.seed(seed=12345) spiketrain = stg.StationaryGammaProcess( - rate=b/a, shape_factor=a, t_stop=t_stop, + rate=b / a, shape_factor=a, t_stop=t_stop, equilibrium=False ).generate_spiketrain() assert_allclose(spiketrain_old.magnitude, spiketrain.magnitude) @@ -378,7 +378,8 @@ def test_compare_with_as_array(self): b = 10 * pq.Hz np.random.seed(27) spiketrain = stg.StationaryGammaProcess( - rate=b/a, shape_factor=a, equilibrium=False).generate_spiketrain() + rate=b / a, shape_factor=a, + equilibrium=False).generate_spiketrain() self.assertIsInstance(spiketrain, neo.SpikeTrain) np.random.seed(27) spiketrain_array = stg.StationaryGammaProcess( @@ -429,7 +430,7 @@ def test_statistics(self): "lognorm", # args are (s, loc, scale) args=(sigma, 0, - (1/rate * np.exp(- sigma**2/2) + (1 / rate * np.exp(- sigma ** 2 / 2) ).rescale(t_stop.units)), alternative='two-sided') self.assertGreater(p, 0.001) @@ -492,8 +493,9 @@ def test_statistics(self): D, p = kstest(intervals.rescale(t_stop.units), "invgauss", # args are (mu, loc, scale) - args=(cv**2, 0, - (1/(rate*cv**2)).rescale(t_stop.units)), + args=(cv ** 2, 0, + (1 / (rate * cv ** 2)).rescale( + t_stop.units)), alternative='two-sided') self.assertGreater(p, 0.001) self.assertLess(D, 0.25) @@ -518,7 +520,7 @@ class FirstSpikeCvTestCase(unittest.TestCase): def setUp(self): np.random.seed(987654321) self.rate = 100. * pq.Hz - self.t_stop = 10.*pq.s + self.t_stop = 10. * pq.s self.n_spiketrains = 10 # can only have CV equal to 1. @@ -534,7 +536,7 @@ def setUp(self): t_stop=self.t_stop, equilibrium=False) - self.poisson_refractory_period_equilibrium =\ + self.poisson_refractory_period_equilibrium = \ stg.StationaryPoissonProcess( rate=self.rate, refractory_period=0.5 / self.rate, @@ -557,7 +559,7 @@ def setUp(self): # CV = sqrt(exp(sigma**2) - 1) self.log_normal_process_ordinary = stg.StationaryLogNormalProcess( rate=self.rate, - sigma=np.sqrt(np.log(5./4.)), + sigma=np.sqrt(np.log(5. / 4.)), t_stop=self.t_stop, equilibrium=False) @@ -570,7 +572,7 @@ def setUp(self): self.inverse_gaussian_process_ordinary = \ stg.StationaryInverseGaussianProcess( rate=self.rate, - cv=1/2, + cv=1 / 2, t_stop=self.t_stop, equilibrium=False) @@ -737,7 +739,6 @@ def test_effective_rate_refractory_period(self): def test_zero_rate(self): for refractory_period in (3 * pq.ms, None): - process = stg.NonStationaryPoissonProcess spiketrain = process( self.rate_profile_0, refractory_period=refractory_period @@ -806,7 +807,7 @@ def test_statistics(self): # Testing type spiketrain_as_array = stg.NonStationaryGammaProcess( rate, shape_factor=shape_factor).generate_spiketrain( - as_array=True) + as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) @@ -878,7 +879,6 @@ def setUp(self): self.t_stop = 10000 * pq.ms def test_poisson(self): - # Check the output types for input rate + n number of neurons pp = stg._n_poisson( rate=self.rate, @@ -897,7 +897,6 @@ def test_poisson(self): self.assertEqual(len(pp), self.n) def test_poisson_error(self): - # Dimensionless rate self.assertRaises( ValueError, stg._n_poisson, rate=5, t_stop=self.t_stop) @@ -937,7 +936,6 @@ def format_check(self, sip, coinc): self.assertEqual(len(sip), self.n) def test_sip(self): - # Generate an example SIP mode sip, coinc = stg.single_interaction_process( n_spiketrains=self.n, t_stop=self.t_stop, rate=self.rate, diff --git a/elephant/test/test_spike_train_surrogates.py b/elephant/test/test_spike_train_surrogates.py index 454208193..32e1a8957 100644 --- a/elephant/test/test_spike_train_surrogates.py +++ b/elephant/test/test_spike_train_surrogates.py @@ -2,7 +2,7 @@ """ unittests for spike_train_surrogates module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -240,16 +240,16 @@ def test_shuffle_isis_with_wrongly_ordered_spikes(self): n_surr = 30 dither = 15 * pq.ms spiketrain = neo.SpikeTrain( - [39.65696411, 98.93868274, 120.2417674, 134.70971166, + [39.65696411, 98.93868274, 120.2417674, 134.70971166, 154.20788924, 160.29077989, 179.19884034, 212.86773029, 247.59488061, 273.04095041, 297.56437605, 344.99204215, 418.55696486, 460.54298334, 482.82299125, - 524.236052, 566.38966742, 597.87562722, 651.26965293, + 524.236052, 566.38966742, 597.87562722, 651.26965293, 692.39802855, - 740.90285815, 849.45874695, 974.57724848, 8.79247605], - t_start=0.*pq.ms, t_stop=1000.*pq.ms, units=pq.ms) + 740.90285815, 849.45874695, 974.57724848, 8.79247605], + t_start=0. * pq.ms, t_stop=1000. * pq.ms, units=pq.ms) surr.surrogates(spiketrain, n_surrogates=n_surr, method=surr_method, dt=dither) @@ -352,13 +352,13 @@ def test_jitter_spikes_same_bins(self): bin_ids_orig = np.array( (spiketrain.view( pq.Quantity) / - bin_size).rescale( + bin_size).rescale( pq.dimensionless).magnitude, dtype=int) bin_ids_surr = np.array( (surrogate_train.view( pq.Quantity) / - bin_size).rescale( + bin_size).rescale( pq.dimensionless).magnitude, dtype=int) self.assertTrue(np.all(bin_ids_orig == bin_ids_surr)) @@ -379,13 +379,13 @@ def test_jitter_spikes_unequal_bin_size(self): bin_ids_orig = np.array( (spiketrain.view( pq.Quantity) / - bin_size).rescale( + bin_size).rescale( pq.dimensionless).magnitude, dtype=int) bin_ids_surr = np.array( (surrogate_train.view( pq.Quantity) / - bin_size).rescale( + bin_size).rescale( pq.dimensionless).magnitude, dtype=int) @@ -402,16 +402,16 @@ def test_surr_method(self): surr_method_kwargs = \ {'dither_spikes': {}, 'dither_spikes_with_refractory_period': {'refractory_period': - 3*pq.ms}, + 3 * pq.ms}, 'randomise_spikes': {}, 'shuffle_isis': {}, 'dither_spike_train': {}, 'jitter_spikes': {}, - 'bin_shuffling': {'bin_size': 3*pq.ms}, + 'bin_shuffling': {'bin_size': 3 * pq.ms}, 'joint_isi_dithering': {}, 'isi_dithering': {}, - 'trial_shifting': {'trial_length': 200*pq.ms, - 'trial_separation': 50*pq.ms}} + 'trial_shifting': {'trial_length': 200 * pq.ms, + 'trial_separation': 50 * pq.ms}} dt = 15 * pq.ms spiketrain = neo.SpikeTrain( @@ -445,7 +445,7 @@ def test_surr_method(self): method='dither_spikes', dt=None) self.assertRaises(TypeError, surr.surrogates, spiketrain.magnitude, - method='dither_spikes', dt=10*pq.ms) + method='dither_spikes', dt=10 * pq.ms) def test_joint_isi_dithering_format(self): @@ -517,7 +517,7 @@ def test_joint_isi_dithering_format(self): # Test surrogate methods wrapper surrogate_trains = surr.surrogates( spiketrain, - dt=15*pq.ms, + dt=15 * pq.ms, n_surrogates=n_surrogates, method='joint_isi_dithering') self.assertIsInstance(surrogate_trains, list) @@ -545,7 +545,7 @@ def test_joint_isi_dithering_output(self): rate=100. * pq.Hz, refractory_period=3 * pq.ms, t_stop=0.1 * pq.s) spiketrain = process.generate_spiketrain() surrogate_train = surr.JointISI(spiketrain).dithering()[0] - ground_truth = [0.0060744, 0.01886591, 0.02732847, 0.03683888, + ground_truth = [0.0060744, 0.01886591, 0.02732847, 0.03683888, 0.04569622, 0.05196334, 0.05899197, 0.07855664] assert_array_almost_equal(surrogate_train.magnitude, ground_truth) @@ -554,16 +554,16 @@ def test_joint_isi_with_wrongly_ordered_spikes(self): n_surr = 30 dither = 15 * pq.ms spiketrain = neo.SpikeTrain( - [39.65696411, 98.93868274, 120.2417674, 134.70971166, + [39.65696411, 98.93868274, 120.2417674, 134.70971166, 154.20788924, 160.29077989, 179.19884034, 212.86773029, 247.59488061, 273.04095041, 297.56437605, 344.99204215, 418.55696486, 460.54298334, 482.82299125, - 524.236052, 566.38966742, 597.87562722, 651.26965293, + 524.236052, 566.38966742, 597.87562722, 651.26965293, 692.39802855, - 740.90285815, 849.45874695, 974.57724848, 8.79247605], - t_start=0.*pq.ms, t_stop=1000.*pq.ms, units=pq.ms) + 740.90285815, 849.45874695, 974.57724848, 8.79247605], + t_start=0. * pq.ms, t_stop=1000. * pq.ms, units=pq.ms) surr.surrogates(spiketrain, n_surrogates=n_surr, method=surr_method, dt=dither) @@ -572,21 +572,21 @@ def test_joint_isi_spikes_at_border(self): n_surr = 30 dither = 15 * pq.ms spiketrain = neo.SpikeTrain( - [4., 28., 45., 51., 83., 87., 96., 111., 126., 131., - 138., 150., - 209., 232., 253., 275., 279., 303., 320., 371., 396., - 401., 429., 447., - 479., 511., 535., 549., 581., 585., 605., 607., 626., - 630., 644., 714., - 832., 835., 853., 858., 878., 905., 909., 932., 950., - 961., 999., 1000.], - t_start=0.*pq.ms, t_stop=1000.*pq.ms, units=pq.ms) + [4., 28., 45., 51., 83., 87., 96., 111., 126., 131., + 138., 150., + 209., 232., 253., 275., 279., 303., 320., 371., 396., + 401., 429., 447., + 479., 511., 535., 549., 581., 585., 605., 607., 626., + 630., 644., 714., + 832., 835., 853., 858., 878., 905., 909., 932., 950., + 961., 999., 1000.], + t_start=0. * pq.ms, t_stop=1000. * pq.ms, units=pq.ms) surr.surrogates( spiketrain, n_surrogates=n_surr, method=surr_method, dt=dither) def test_bin_shuffling_output_format(self): - self.bin_size = 3*pq.ms + self.bin_size = 3 * pq.ms self.max_displacement = 10 spiketrain = neo.SpikeTrain([90, 93, 97, 100, 105, 150, 180, 350] * pq.ms, t_stop=.5 * pq.s) diff --git a/elephant/test/test_sta.py b/elephant/test/test_sta.py index 8d04731d5..14214320e 100644 --- a/elephant/test/test_sta.py +++ b/elephant/test/test_sta.py @@ -2,7 +2,7 @@ """ Tests for the function sta module -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -26,16 +26,16 @@ class sta_TestCase(unittest.TestCase): def setUp(self): self.asiga0 = AnalogSignal(np.array([ np.sin(np.arange(0, 20 * math.pi, 0.1))]).T, - units='mV', sampling_rate=10 / ms) + units='mV', sampling_rate=10 / ms) self.asiga1 = AnalogSignal(np.array([ np.sin(np.arange(0, 20 * math.pi, 0.1)), np.cos(np.arange(0, 20 * math.pi, 0.1))]).T, - units='mV', sampling_rate=10 / ms) + units='mV', sampling_rate=10 / ms) self.asiga2 = AnalogSignal(np.array([ np.sin(np.arange(0, 20 * math.pi, 0.1)), np.cos(np.arange(0, 20 * math.pi, 0.1)), np.tan(np.arange(0, 20 * math.pi, 0.1))]).T, - units='mV', sampling_rate=10 / ms) + units='mV', sampling_rate=10 / ms) self.st0 = SpikeTrain( [9 * math.pi, 10 * math.pi, 11 * math.pi, 12 * math.pi], units='ms', t_stop=self.asiga0.t_stop) @@ -76,7 +76,7 @@ def test_spike_triggered_average_with_shifted_sin_wave(self): def test_only_one_spike(self): """The output should be the same as the input""" x = np.arange(0, 20, 0.1) - y = x**2 + y = x ** 2 sr = 10 / ms z = AnalogSignal(np.array([y]).T, units='mV', sampling_rate=sr) spiketime = 8 * ms @@ -226,7 +226,8 @@ def test_all_spiketrains_empty(self): # Tests for new scipy verison (with scipy.signal.coherence) # ========================================================================= -@unittest.skipIf(not hasattr(scipy.signal, 'coherence'), "Please update scipy " +@unittest.skipIf(not hasattr(scipy.signal, 'coherence'), + "Please update scipy " "to a version >= 0.16") class sfc_TestCase_new_scipy(unittest.TestCase): @@ -278,7 +279,7 @@ def setUp(self): self.st4 = SpikeTrain(np.arange( (tlen0.rescale(pq.ms).magnitude * .25), (tlen0.rescale(pq.ms).magnitude * .75), 50) * pq.ms, - t_start=5 * fs0, t_stop=tlen0 - 5 * fs0) + t_start=5 * fs0, t_stop=tlen0 - 5 * fs0) self.bst4 = BinnedSpikeTrain(self.st4, bin_size=fs0) # spike train with incompatible bin_size diff --git a/elephant/test/test_statistics.py b/elephant/test/test_statistics.py index 1c7649593..385e860b1 100644 --- a/elephant/test/test_statistics.py +++ b/elephant/test/test_statistics.py @@ -2,7 +2,7 @@ """ Unit tests for the statistics module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ from __future__ import division @@ -1065,11 +1065,12 @@ def test_complexity_pdf_deprecated(self): spiketrain_a, spiketrain_b, spiketrain_c] # runs the previous function which will be deprecated targ = np.array([0.92, 0.01, 0.01, 0.06]) + complexity = statistics.complexity_pdf( spiketrains, bin_size=0.1*pq.s) assert_array_equal(targ, complexity.magnitude[:, 0]) self.assertEqual(1, complexity.magnitude[:, 0].sum()) - self.assertEqual(len(spiketrains)+1, len(complexity)) + self.assertEqual(len(spiketrains) + 1, len(complexity)) self.assertIsInstance(complexity, neo.AnalogSignal) self.assertEqual(complexity.units, 1 * pq.dimensionless) @@ -1089,18 +1090,17 @@ def test_complexity_pdf(self): pdf = complexity_obj.pdf() assert_array_equal(targ, complexity_obj.pdf().magnitude[:, 0]) self.assertEqual(1, pdf.magnitude[:, 0].sum()) - self.assertEqual(len(spiketrains)+1, len(pdf)) + self.assertEqual(len(spiketrains) + 1, len(pdf)) self.assertIsInstance(pdf, neo.AnalogSignal) - self.assertEqual(pdf.units, 1*pq.dimensionless) + self.assertEqual(pdf.units, 1 * pq.dimensionless) def test_complexity_histogram_spread_0(self): - sampling_rate = 1 / pq.s spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, - t_stop=20*pq.s), + t_stop=20 * pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, - t_stop=20*pq.s)] + t_stop=20 * pq.s)] correct_histogram = np.array([10, 8, 2]) @@ -1119,13 +1119,12 @@ def test_complexity_histogram_spread_0(self): correct_time_histogram) def test_complexity_epoch_spread_0(self): - sampling_rate = 1 / pq.s spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, - t_stop=20*pq.s), + t_stop=20 * pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, - t_stop=20*pq.s)] + t_stop=20 * pq.s)] complexity_obj = statistics.Complexity(spiketrains, sampling_rate=sampling_rate, @@ -1135,13 +1134,12 @@ def test_complexity_epoch_spread_0(self): neo.Epoch) def test_complexity_histogram_spread_1(self): - sampling_rate = 1 / pq.s spiketrains = [neo.SpikeTrain([0, 1, 5, 9, 11, 13, 20] * pq.s, - t_stop=21*pq.s), + t_stop=21 * pq.s), neo.SpikeTrain([1, 4, 7, 12, 16, 18] * pq.s, - t_stop=21*pq.s)] + t_stop=21 * pq.s)] correct_histogram = np.array([9, 5, 1, 2]) @@ -1160,13 +1158,12 @@ def test_complexity_histogram_spread_1(self): correct_time_histogram) def test_complexity_histogram_spread_2(self): - sampling_rate = 1 / pq.s spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 13, 20] * pq.s, - t_stop=21*pq.s), + t_stop=21 * pq.s), neo.SpikeTrain([1, 4, 7, 12, 16, 18] * pq.s, - t_stop=21*pq.s)] + t_stop=21 * pq.s)] correct_histogram = np.array([5, 0, 1, 1, 0, 0, 0, 1]) @@ -1186,9 +1183,9 @@ def test_complexity_histogram_spread_2(self): def test_wrong_input_errors(self): spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 13, 20] * pq.s, - t_stop=21*pq.s), + t_stop=21 * pq.s), neo.SpikeTrain([1, 4, 7, 12, 16, 18] * pq.s, - t_stop=21*pq.s)] + t_stop=21 * pq.s)] self.assertRaises(ValueError, statistics.Complexity, @@ -1197,22 +1194,21 @@ def test_wrong_input_errors(self): self.assertRaises(ValueError, statistics.Complexity, spiketrains, - sampling_rate=1*pq.s, + sampling_rate=1 * pq.s, spread=-7) def test_sampling_rate_warning(self): spiketrains = [neo.SpikeTrain([1, 5, 9, 11, 13, 20] * pq.s, - t_stop=21*pq.s), + t_stop=21 * pq.s), neo.SpikeTrain([1, 4, 7, 12, 16, 18] * pq.s, - t_stop=21*pq.s)] + t_stop=21 * pq.s)] with self.assertWarns(UserWarning): statistics.Complexity(spiketrains, - bin_size=1*pq.s, + bin_size=1 * pq.s, spread=1) def test_binning_for_input_with_rounding_errors(self): - # a test with inputs divided by 30000 which leads to rounding errors # these errors have to be accounted for by proper binning; # check if we still get the correct result diff --git a/elephant/test/test_unitary_event_analysis.py b/elephant/test/test_unitary_event_analysis.py index eba33f976..18504649b 100644 --- a/elephant/test/test_unitary_event_analysis.py +++ b/elephant/test/test_unitary_event_analysis.py @@ -1,7 +1,7 @@ """ Unit tests for the Unitary Events analysis -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/test/test_waveform_features.py b/elephant/test/test_waveform_features.py index aff400afa..06a210995 100644 --- a/elephant/test/test_waveform_features.py +++ b/elephant/test/test_waveform_features.py @@ -1,7 +1,7 @@ """ Unit tests for the waveform_feature module. -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/elephant/unitary_event_analysis.py b/elephant/unitary_event_analysis.py index 2cf51b747..a91a57759 100644 --- a/elephant/unitary_event_analysis.py +++ b/elephant/unitary_event_analysis.py @@ -45,7 +45,7 @@ jointJ_window_analysis -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ @@ -334,8 +334,8 @@ def _n_exp_mat_analytic(mat, pattern_hash): nrep = m.shape[1] # multipyling the marginal probability of neurons with regard to the # pattern - pmat = np.multiply(m, np.tile(marg_prob, (1, nrep))) + \ - np.multiply(1 - m, np.tile(1 - marg_prob, (1, nrep))) + pmat = np.multiply(m, np.tile(marg_prob, (1, nrep))) \ + + np.multiply(1 - m, np.tile(1 - marg_prob, (1, nrep))) return np.prod(pmat, axis=0) * float(mat.shape[1]) diff --git a/elephant/waveform_features.py b/elephant/waveform_features.py index 0fa3acd6f..aa4c43157 100644 --- a/elephant/waveform_features.py +++ b/elephant/waveform_features.py @@ -6,7 +6,7 @@ waveform_width waveform_snr -:copyright: Copyright 2014-2020 by the Elephant team, see `doc/authors.rst`. +:copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ diff --git a/setup.py b/setup.py index ed2c0f1f7..f972085fc 100644 --- a/setup.py +++ b/setup.py @@ -65,6 +65,7 @@ author_email="contact@python-elephant.org", description="Elephant is a package for analysis of electrophysiology data in Python", long_description=long_description, + long_description_content_type="text/markdown", license="BSD", url='http://python-elephant.org', python_requires=">=3.7", From d7ee38e853ff5a92cfdd3f925aff4b052bdd8b5b Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Wed, 30 Mar 2022 19:49:49 +0200 Subject: [PATCH 51/63] included files for spade (#466) --- MANIFEST.in | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MANIFEST.in b/MANIFEST.in index 22f076658..f6dce7248 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -7,6 +7,8 @@ include elephant/VERSION include elephant/current_source_density_src/README.md include elephant/current_source_density_src/test_data.mat include elephant/spade_src/LICENSE +include elephant/spade_src/src/fim.cpp +recursive-include elephant/spade_src/include *.h include elephant/test/spike_extraction_test_data.txt recursive-include doc * prune doc/_build From 5a26a8a0a53dbfeaf6d45564c19f9c909c7cf0e7 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 31 Mar 2022 19:40:36 +0200 Subject: [PATCH 52/63] Improvement of Spike Time Tiling Coefficient (STTC) (#438) * Update spike_train_correlation.py Improvement of Spike Time Tiling Coefficient (STTC) calculation by utilizing numpy function. Details: - use numpy.where to find overlapping tiles in run_T - some comments elaborated/changed - changed name of time_A to time_max for maximum time covered by tiles This enhancement was inspired by Thierry Nieus --- elephant/spike_train_correlation.py | 34 ++++++++++++++++++----------- 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/elephant/spike_train_correlation.py b/elephant/spike_train_correlation.py index 8ba37b69c..a70c0a074 100644 --- a/elephant/spike_train_correlation.py +++ b/elephant/spike_train_correlation.py @@ -926,26 +926,34 @@ def run_T(spiketrain): N = len(spiketrain) time_A = 2 * N * dt # maximum possible time - if N == 1: # for just one spike in train + if N == 1: # for only a single spike in the train + + # Check difference between start of recording and single spike if spiketrain[0] - spiketrain.t_start < dt: - time_A += -dt + spiketrain[0] - spiketrain.t_start - if spiketrain[0] + dt > spiketrain.t_stop: - time_A += -dt - spiketrain[0] + spiketrain.t_stop - else: # if more than one spike in train - # Vectorized loop of spike time differences + time_A += - dt + spiketrain[0] - spiketrain.t_start + + # Check difference between single spike and end of recording + elif spiketrain[0] + dt > spiketrain.t_stop: + time_A += - dt - spiketrain[0] + spiketrain.t_stop + + else: # if more than a single spike in the train + + # Calculate difference between consecutive spikes diff = np.diff(spiketrain) - diff_overlap = diff[diff < 2 * dt] - # Subtract overlap - time_A += -2 * dt * len(diff_overlap) + np.sum(diff_overlap) - # check if spikes are within dt of the start and/or end - # if so subtract overlap of first and/or last spike + # Find spikes whose tiles overlap + idx = np.where(diff < 2 * dt)[0] + # Subtract overlapping "2*dt" tiles and add differences instead + time_A += - 2 * dt * len(idx) + diff[idx].sum() + + # Check if spikes are within +/-dt of the start and/or end + # if so, subtract overlap of first and/or last spike if (spiketrain[0] - spiketrain.t_start) < dt: time_A += spiketrain[0] - dt - spiketrain.t_start - if (spiketrain.t_stop - spiketrain[N - 1]) < dt: - time_A += -spiketrain[-1] - dt + spiketrain.t_stop + time_A += - spiketrain[-1] - dt + spiketrain.t_stop + # Calculate the proportion of total recorded time to "tiled" time T = time_A / (spiketrain.t_stop - spiketrain.t_start) return T.simplified.item() # enforce simplification, strip units From 59111ca15165beb462c869554052714ae18b907a Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 1 Apr 2022 10:01:40 +0200 Subject: [PATCH 53/63] bumped version number after release of v0.11.0 (#467) --- elephant/VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/elephant/VERSION b/elephant/VERSION index 142464bf2..5a267eebd 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.11.0 \ No newline at end of file +0.12.0b1 From 23d0680ec45cf8d28a79f3d4e0b387516104b09f Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 14 Apr 2022 16:01:49 +0200 Subject: [PATCH 54/63] remove version cap for scipy (#473) --- requirements/requirements.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 25f8e040b..d5495dc11 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,7 +1,6 @@ neo>=0.10.0 numpy>=1.18.1 quantities>=0.12.1 -scipy<1.7.0 -#scipy>=1.5.4 +scipy>=1.5.4 six>=1.10.0 tqdm From ee5c1906f37f0f6e41f9810dca5c39cb313b7da5 Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 14 Apr 2022 16:52:58 +0200 Subject: [PATCH 55/63] disable mac installs for now in setup.py (#472) * removed compilation of fim for darwin * compile only on Linux Windows --- setup.py | 44 ++++++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/setup.py b/setup.py index f972085fc..c9aa8e49b 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -import os +import os.path import platform from setuptools import setup, Extension @@ -40,7 +40,7 @@ '-Weffc++', '-Wunused-result', '-Werror', '-Werror=return-type', '-Xpreprocessor', '-fopenmp', '-std=gnu++17']) -else: +elif platform.system() == "Linux": fim_module = Extension( name='elephant.spade_src.fim', sources=['elephant/spade_src/src/fim.cpp'], @@ -53,23 +53,22 @@ '-Weffc++', '-Wunused-result', '-Werror', '-fopenmp', '-std=gnu++17']) -setup( - name="elephant", - version=version, - packages=['elephant', 'elephant.test'], - include_package_data=True, - ext_modules=[fim_module], - install_requires=install_requires, - extras_require=extras_require, - author="Elephant authors and contributors", - author_email="contact@python-elephant.org", - description="Elephant is a package for analysis of electrophysiology data in Python", - long_description=long_description, - long_description_content_type="text/markdown", - license="BSD", - url='http://python-elephant.org', - python_requires=">=3.7", - classifiers=[ +setup_kwargs = { + "name": "elephant", + "version": version, + "packages": ['elephant', 'elephant.test'], + "include_package_data": True, + "install_requires": install_requires, + "extras_require": extras_require, + "author": "Elephant authors and contributors", + "author_email": "contact@python-elephant.org", + "description": "Elephant is a package for analysis of electrophysiology data in Python", # noqa + "long_description": long_description, + "long_description_content_type": "text/markdown", + "license": "BSD", + "url": 'http://python-elephant.org', + "python_requires": ">=3.7", + "classifiers": [ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: BSD License', @@ -82,4 +81,9 @@ 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3 :: Only', 'Topic :: Scientific/Engineering'] -) +} +# do not compile external modules on darwin +if platform.system() in ["Windows", "Linux"]: + setup_kwargs["ext_modules"] = [fim_module] + +setup(**setup_kwargs) From bbab36859b96c881af5d43e8e6e3cd6de4f21fce Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 14 Apr 2022 16:56:20 +0200 Subject: [PATCH 56/63] added example to docstring, removed reference to annotations (#468) * added example to docstring, removed reference to annotations * fixed doctest for conversion --- elephant/asset/asset.py | 4 +-- elephant/conversion.py | 58 +++++++++++++++++++++++++------------- elephant/test/test_icsd.py | 6 ++-- 3 files changed, 43 insertions(+), 25 deletions(-) diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index 2cf1f7986..ef9c56925 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -2200,8 +2200,7 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, significant value in `pmat` (extreme case: `pmat[i, j] = 1`) yields joint significance of itself and its neighbors. Default: 1e-5 -<<<<<<< HEAD:elephant/asset.py -======= + precision : {'float', 'double'}, optional Single or double floating-point precision for the resulting `jmat` matrix. @@ -2237,7 +2236,6 @@ def joint_probability_matrix(self, pmat, filter_shape, n_largest, resulting joint prob. matrix values are outside of the acceptable range ``[-tolerance, 1.0 + tolerance]``. Default: 1e-5 ->>>>>>> master:elephant/asset/asset.py Returns ------- diff --git a/elephant/conversion.py b/elephant/conversion.py index 0c0cf3857..ecf4b06eb 100644 --- a/elephant/conversion.py +++ b/elephant/conversion.py @@ -24,8 +24,8 @@ ... neo.SpikeTrain([0.1, 0.7, 1.2, 2.2, 4.3, 5.5, 8.0], t_stop=9, units='s') ... ] >>> bst = BinnedSpikeTrain(spiketrains, bin_size=1 * pq.s) ->>> bst -BinnedSpikeTrain(t_start=0.0 s, t_stop=9.0 s, bin_size=1.0 s; shape=(2, 9)) +>>> bst # doctest: +ELLIPSIS +BinnedSpikeTrain(t_start=0.0 s, t_stop=9.0 s, bin_size=1.0 s; shape=(2, 9), ... >>> bst.to_array() array([[2, 1, 0, 1, 1, 1, 1, 0, 0], [2, 1, 1, 0, 1, 1, 0, 0, 1]], dtype=int32) @@ -37,26 +37,27 @@ [ True, True, True, False, True, True, False, False, True]]) >>> bst_binary = bst.binarize() ->>> bst_binary -BinnedSpikeTrainView(t_start=0.0 s, t_stop=9.0 s, bin_size=1.0 s; shape=(2, 9)) +>>> bst_binary # doctest: +ELLIPSIS +BinnedSpikeTrainView(t_start=0.0 s, t_stop=9.0 s, bin_size=1.0 s; shape=(2, ... >>> bst_binary.to_array() array([[1, 1, 0, 1, 1, 1, 1, 0, 0], [1, 1, 1, 0, 1, 1, 0, 0, 1]], dtype=int32) Slicing. ->>> bst.time_slice(t_stop=3.5 * pq.s) -BinnedSpikeTrainView(t_start=0.0 s, t_stop=3.0 s, bin_size=1.0 s; shape=(2, 3)) ->>> bst[0, 1:-3] -BinnedSpikeTrainView(t_start=1.0 s, t_stop=6.0 s, bin_size=1.0 s; shape=(1, 5)) +>>> bst.time_slice(t_stop=3.5 * pq.s) # doctest: +ELLIPSIS +BinnedSpikeTrainView(t_start=0.0 s, t_stop=3.0 s, bin_size=1.0 s; shape=(2, ... +>>> bst[0, 1:-3] # doctest: +ELLIPSIS +BinnedSpikeTrainView(t_start=1.0 s, t_stop=6.0 s, bin_size=1.0 s; shape=(1, ... Generate a realisation of spike trains from the binned version. ->>> bst.to_spike_trains(spikes='center') -[, -] +>>> print(bst.to_spike_trains(spikes='center')[0]) +[0.33333333 0.66666667 1.5 3.5 4.5 5.5 + 6.5 ] s +>>> print(bst.to_spike_trains(spikes='center')[1]) +[0.33333333 0.66666667 1.5 2.5 4.5 5.5 + 8.5 ] s Check the correctness of a spike trains realosation @@ -66,9 +67,8 @@ Rescale the units of a binned spike train without changing the data. >>> bst.rescale('ms') ->>> bst -BinnedSpikeTrain(t_start=0.0 ms, t_stop=9000.0 ms, bin_size=1000.0 ms; -shape=(2, 9)) +>>> bst # doctest: +ELLIPSIS +BinnedSpikeTrain(t_start=0.0 ms, t_stop=9000.0 ms, bin_size=1000.0 ms; ... :copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: BSD, see LICENSE.txt for details. @@ -945,11 +945,11 @@ def spike_indices(self): >>> x = conv.BinnedSpikeTrain(st, n_bins=10, bin_size=1 * pq.s, ... t_start=0 * pq.s) >>> print(x.spike_indices) - [[0, 0, 1, 3, 4, 5, 6]] + [array([0, 0, 1, 3, 4, 5, 6], dtype=int32)] >>> print(x.sparse_matrix.nonzero()[1]) [0 1 3 4 5 6] >>> print(x.to_array()) - [[2, 1, 0, 1, 1, 1, 1, 0, 0, 0]] + [[2 1 0 1 1 1 1 0 0 0]] """ spike_idx = [] @@ -1267,6 +1267,27 @@ def discretise_spiketimes(spiketrains, sampling_rate): ------- neo.SpikeTrain or list of neo.SpikeTrain The discretised spiketrain(s) + + Examples + -------- + >>> import neo + >>> import numpy as np + >>> import quantities as pq + >>> from elephant import conversion + >>> + >>> np.random.seed(1) + >>> times = (np.arange(10) + np.random.uniform(size=10)) * pq.ms + >>> spiketrain = neo.SpikeTrain(times, t_stop=10*pq.ms) + >>> + >>> spiketrain.times + array([0.417022 , 1.72032449, 2.00011437, 3.30233257, 4.14675589, + 5.09233859, 6.18626021, 7.34556073, 8.39676747, 9.53881673]) * ms + >>> + >>> discretised_spiketrain = conversion.discretise_spiketimes(spiketrain, + ... 1 / pq.ms) + >>> discretised_spiketrain.times + array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) * ms + """ # spiketrains type check was_single_spiketrain = False @@ -1307,7 +1328,6 @@ def discretise_spiketimes(spiketrains, sampling_rate): discrete_times *= units new_spiketrain = spiketrain.duplicate_with_new_data(discrete_times) - new_spiketrain.annotations = spiketrain.annotations new_spiketrain.sampling_rate = sampling_rate new_spiketrains.append(new_spiketrain) diff --git a/elephant/test/test_icsd.py b/elephant/test/test_icsd.py index 2b4bb844c..16d7de6d1 100644 --- a/elephant/test/test_icsd.py +++ b/elephant/test/test_icsd.py @@ -130,9 +130,9 @@ def potential_of_cylinder(z_j, Tested with - >>>from sympy import * - >>>C_i, z_i, h, z_j, z_j, sigma, R = symbols('C_i z_i h z z_j sigma R') - >>>C_i*integrate(1/(2*sigma)*(sqrt((z-z_j)**2 + R**2) - + >>> from sympy import * + >>> C_i, z_i, h, z_j, z_j, sigma, R = symbols('C_i z_i h z z_j sigma R') + >>> C_i*integrate(1/(2*sigma)*(sqrt((z-z_j)**2 + R**2) - ... abs(z-z_j)), (z, z_i-h/2, z_i+h/2)) From d045dbdf22530f8e954531fdf82569083ec60a7c Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 14 Apr 2022 17:21:29 +0200 Subject: [PATCH 57/63] Fix/asset on mac os, add CI workflow for macOS (#474) * removed compilation of fim for darwin * changed precision in asset to double, added 2 github action runners for macOS * removed viziphant from environment-tests.yml * Update setup.py Co-authored-by: Michael Denker --- .github/workflows/CI.yml | 339 +++++++++++++++++------------ elephant/asset/asset.py | 2 +- requirements/environment-tests.yml | 2 +- setup.py | 1 + 4 files changed, 197 insertions(+), 147 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 2119be6c1..417bfd25e 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -12,9 +12,9 @@ on: default: 'warning' type: choice options: - - info - - warning - - debug + - info + - warning + - debug pull_request: branches: - master @@ -106,111 +106,114 @@ jobs: source ~/test_env/bin/activate pytest --cov=elephant - # install dependencies with conda and run tests with pytest - test-conda: + test-macOS: + name: conda (${{ matrix.python-version }}, ${{ matrix.os }}) runs-on: ${{ matrix.os }} strategy: + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false matrix: # OS [ubuntu-latest, macos-latest, windows-latest] - os: [ubuntu-latest] + os: [macos-10.15,macos-latest] + python-version: [3.9] + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" - # do not cancel all in-progress jobs if any matrix job fails - fail-fast: false + - uses: actions/checkout@v2 - steps: - - uses: actions/checkout@v2 + - name: Cache conda + uses: actions/cache@v2 + with: + path: ~/conda_pkgs_dir + key: ${{ runner.os }}-conda-${{hashFiles('requirements/environment.yml') }}-${{ steps.date.outputs.date }} - - name: Cache pip - uses: actions/cache@v2 - with: - path: ~/.cache/pip - key: ${{ runner.os }}-pip-${{hashFiles('requirements/environment-tests.yml') }}-${{ steps.date.outputs.date }} + - uses: conda-incubator/setup-miniconda@v2 + with: + auto-update-conda: true + python-version: ${{ matrix.python-version }} + activate-environment: elephant + environment-file: requirements/environment-tests.yml + auto-activate-base: false + use-only-tar-bz2: true # IMPORTANT: This needs to be set for caching to work properly! - - name: Add conda to system path - run: | - # $CONDA is an environment variable pointing to the root of the miniconda directory - echo $CONDA/bin >> $GITHUB_PATH - - - name: Install dependencies - run: | - conda update conda - conda env update --file requirements/environment-tests.yml --name base - - activate base - conda install -c conda-forge openmpi - pip install -r requirements/requirements-tests.txt - pip install pytest==6.2.5 # hotfix for pytest 7.0.0, remove once fixed - pip install pytest-cov coveralls - pip install . - - - name: List packages - run: | - activate base - pip list - conda list - python --version - - - name: Test with pytest - run: | - activate base - pytest --cov=elephant --import-mode=importlib + - name: Install dependencies + shell: bash -l {0} + run: | + python --version + conda env list + conda install pytest + conda install pytest-cov coveralls + pip install -e .[extras] + + - name: List packages + shell: bash -l {0} + run: | + pip list + conda list + python --version + + - name: Test with pytest + shell: bash -l {0} + run: | + pytest --cov=elephant # install dependencies with pip and run tests with pytest test-pip: - runs-on: ${{ matrix.os }} - strategy: - matrix: - # python versions for elephant: [3.6, 3.7, 3.8, 3.9] - python-version: [3.8,] - # OS [ubuntu-latest, macos-latest, windows-latest] - os: [windows-latest] - include: - # - os: ubuntu-latest - # path: ~/.cache/pip - # - os: macos-latest - # path: ~/Library/Caches/pip + runs-on: ${{ matrix.os }} + strategy: + matrix: + # python versions for elephant: [3.6, 3.7, 3.8, 3.9] + python-version: [3.8,] + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [windows-latest] + include: + # - os: ubuntu-latest + # path: ~/.cache/pip + # - os: macos-latest + # path: ~/Library/Caches/pip - os: windows-latest path: ~\AppData\Local\pip\Cache - # do not cancel all in-progress jobs if any matrix job fails - fail-fast: false - - steps: - - name: Get current year-month - id: date - run: echo "::set-output name=date::$(date +'%Y-%m')" - - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - - name: Cache pip - uses: actions/cache@v2 - with: - path: ${{ matrix.path }} - # Look to see if there is a cache hit for the corresponding requirements files - key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} - -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install -r requirements/requirements-tests.txt - pip install -r requirements/requirements.txt - pip install -r requirements/requirements-extras.txt - pip install pytest-cov coveralls - pip install -e . - - - name: List packages - run: | - pip list - python --version - - - name: Test with pytest - run: | - python --version - pytest --cov=elephant + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ${{ matrix.path }} + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ hashFiles('**/requirements-tests.txt') }} + -${{ hashFiles('**/requirements-extras.txt') }}-${{ hashFiles('setup.py') }} -${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements/requirements-tests.txt + pip install -r requirements/requirements.txt + pip install -r requirements/requirements-extras.txt + pip install pytest-cov coveralls + pip install -e . + + - name: List packages + run: | + pip list + python --version + + - name: Test with pytest + run: | + pytest --cov=elephant # install dependencies and elephant with pip and run MPI test-pip-MPI: @@ -267,55 +270,101 @@ jobs: run: | mpiexec -n 1 python -m mpi4py -m pytest --cov=elephant + # install dependencies with conda and run tests with pytest + test-conda: + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + # do not cancel all in-progress jobs if any matrix job fails + fail-fast: false + + steps: + - uses: actions/checkout@v2 + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + key: ${{ runner.os }}-pip-${{hashFiles('requirements/environment-tests.yml') }}-${{ steps.date.outputs.date }} + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + - name: Install dependencies + run: | + conda update conda + conda env update --file requirements/environment-tests.yml --name base + activate base + conda install -c conda-forge openmpi + pip install -r requirements/requirements-tests.txt + pip install pytest + pip install pytest-cov coveralls + pip install . + - name: List packages + run: | + activate base + pip list + conda list + python --version + - name: Test with pytest + run: | + activate base + pytest --cov=elephant --import-mode=importlib + # install dependencies for the documentation and build .html docs: - runs-on: ${{ matrix.os }} - strategy: - matrix: - # OS [ubuntu-latest, macos-latest, windows-latest] - os: [ubuntu-latest] - - steps: - - - name: Get current year-month - id: date - run: echo "::set-output name=date::$(date +'%Y-%m')" - - - uses: actions/checkout@v2 - - - name: Add conda to system path - run: | - # $CONDA is an environment variable pointing to the root of the miniconda directory - echo $CONDA/bin >> $GITHUB_PATH - - - name: Cache pip - uses: actions/cache@v2 - with: - path: ~/.cache/pip - # Look to see if there is a cache hit for the corresponding requirements files - key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ hashFiles('**/environment-docs.yml') }}-${{ steps.date.outputs.date }} - - - name: Install dependencies - run: | - sudo apt install -y libopenmpi-dev openmpi-bin - python -m pip install --upgrade pip - pip install -r requirements/requirements-docs.txt - pip install -r requirements/requirements-tutorials.txt - conda update conda - conda env update --file requirements/environment-docs.yml --name base - conda install -c conda-forge openmpi - conda install -c conda-forge pandoc - pip install -e .[extras] - # run notebooks - sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py - - - name: List packages - run: | - pip list - conda list - python --version - - - name: make html - run: | - cd doc - make html + name: docs (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + matrix: + # OS [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-latest] + + steps: + + - name: Get current year-month + id: date + run: echo "::set-output name=date::$(date +'%Y-%m')" + + - uses: actions/checkout@v2 + + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + + - name: Cache pip + uses: actions/cache@v2 + with: + path: ~/.cache/pip + # Look to see if there is a cache hit for the corresponding requirements files + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements-docs.txt') }}-${{ hashFiles('**/requirements-tutorials.txt') }}-${{ hashFiles('**/environment-docs.yml') }}-${{ steps.date.outputs.date }} + + - name: Install dependencies + run: | + sudo apt install -y libopenmpi-dev openmpi-bin + python -m pip install --upgrade pip + pip install -r requirements/requirements-docs.txt + pip install -r requirements/requirements-tutorials.txt + conda update conda + conda env update --file requirements/environment-docs.yml --name base + conda install -c conda-forge openmpi + conda install -c conda-forge pandoc + pip install -e .[extras] + # run notebooks + sed -i -E "s/nbsphinx_execute *=.*/nbsphinx_execute = 'always'/g" doc/conf.py + + - name: List packages + run: | + pip list + conda list + python --version + + - name: make html + run: | + cd doc + make html diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index ef9c56925..7a28089b5 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -427,7 +427,7 @@ def calculate_stretch_mat(theta_mat, D_mat): dY = y_array.T - y_array # Compute the matrix Theta of angles between each pair of points - theta = np.arctan2(dY, dX, dtype=np.float32) + theta = np.arctan2(dY, dX, dtype=np.float64) stretch_mat = calculate_stretch_mat(theta, D) else: diff --git a/requirements/environment-tests.yml b/requirements/environment-tests.yml index 2068f16e5..ac1e42516 100644 --- a/requirements/environment-tests.yml +++ b/requirements/environment-tests.yml @@ -16,5 +16,5 @@ dependencies: - jinja2 - pip: - neo>=0.10.0 - - viziphant + # - viziphant # neo, viziphant can be removed once it is integrated into requirements-tutorials.txt diff --git a/setup.py b/setup.py index c9aa8e49b..7960705ad 100644 --- a/setup.py +++ b/setup.py @@ -86,4 +86,5 @@ if platform.system() in ["Windows", "Linux"]: setup_kwargs["ext_modules"] = [fim_module] + setup(**setup_kwargs) From 378bc593ead97a9a46583ddd0a7c59ad80db47ce Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 14 Apr 2022 17:36:22 +0200 Subject: [PATCH 58/63] Release 0.11.1 (#475) * bumped version number to 0.11.1 * added doi for elephant 0.11.0 to citation * fixed typo in version * added initial draft of release note to release_notes.rst * fixed link to all versions of elephant * updated release notes * edited section to cite specific elephant version * update title in .zenodo.json --- .zenodo.json | 2 +- doc/citation.rst | 17 ++++------------- doc/release_notes.rst | 24 ++++++++++++++++++++++++ elephant/VERSION | 2 +- 4 files changed, 30 insertions(+), 15 deletions(-) diff --git a/.zenodo.json b/.zenodo.json index 240195b29..b8933c2e9 100644 --- a/.zenodo.json +++ b/.zenodo.json @@ -72,7 +72,7 @@ } ], - "title": "Elephant 0.11.0", + "title": "Elephant 0.11.1", "keywords": [ "neuroscience", diff --git a/doc/citation.rst b/doc/citation.rst index 62896cdca..92bcf0f7b 100644 --- a/doc/citation.rst +++ b/doc/citation.rst @@ -3,21 +3,12 @@ Citing Elephant *************** To refer to the Elephant software package in publications, please use: -Elephant (`doi:10.5281/zenodo.1186602 `_; +Elephant (`doi:10.5281/zenodo.1186602 `_; `RRID:SCR_003833 `_) -To cite a specific version of Elephant use: - -* v0.10.0 `doi:10.5281/zenodo.4582366 `_ -* v0.9.0 `doi:10.5281/zenodo.4271489 `_ -* v0.8.0 `doi:10.5281/zenodo.3975676 `_ -* v0.7.0 `doi:10.5281/zenodo.3695277 `_ -* v0.6.4 `doi:10.5281/zenodo.3524331 `_ -* v0.6.3 `doi:10.5281/zenodo.3346596 `_ -* v0.6.1 `doi:10.5281/zenodo.2620229 `_ -* v0.5.0 `doi:10.5281/zenodo.1216145 `_ -* v0.4.3 `doi:10.5281/zenodo.1187084 `_ -* v0.4.2 `doi:10.5281/zenodo.1186603 `_ +To cite a specific version of Elephant please see version-specific DOIs at: + + `doi:10.5281/zenodo.1186602 `_ To cite Elephant, please use: diff --git a/doc/release_notes.rst b/doc/release_notes.rst index f37be2b90..eba563f83 100644 --- a/doc/release_notes.rst +++ b/doc/release_notes.rst @@ -2,6 +2,30 @@ Release Notes ============= +Elephant 0.11.1 release notes +============================= + +Bug fixes +------------- +* Fix installation on macOS (#472) + +Documentation +------------- +* Added example to `asset.discretise_spiketimes` docstring (#468) + +Optimizations +------------- +* Performance improvement of Spike Time Tiling Coefficient (STTC) (#438) + +Other changes +------------- +* Continuous Integration (CI): added two workflows for macOS (#474) +* Fixed failing unit test asset on macOS (#474) + +Selected dependency changes +------------- +* scipy >=1.5.4 (#473) + Elephant 0.11.0 release notes ============================= diff --git a/elephant/VERSION b/elephant/VERSION index 5a267eebd..af88ba824 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.12.0b1 +0.11.1 From 6928e3bd85a2ff683ff9ce4da731824b17bbb6de Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 21 Apr 2022 17:27:58 +0200 Subject: [PATCH 59/63] Bump version number after release 0.11.1 (#476) --- elephant/VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/elephant/VERSION b/elephant/VERSION index af88ba824..5a267eebd 100644 --- a/elephant/VERSION +++ b/elephant/VERSION @@ -1 +1 @@ -0.11.1 +0.12.0b1 From 7f2a01cc50e36acdfc276cf359c430e9621de43d Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Thu, 21 Apr 2022 17:28:21 +0200 Subject: [PATCH 60/63] fix headings for release notes, elephant versions > 0.10.0 (#477) --- doc/release_notes.rst | 47 ++++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 25 deletions(-) diff --git a/doc/release_notes.rst b/doc/release_notes.rst index eba563f83..d54361527 100644 --- a/doc/release_notes.rst +++ b/doc/release_notes.rst @@ -6,7 +6,7 @@ Elephant 0.11.1 release notes ============================= Bug fixes -------------- +--------- * Fix installation on macOS (#472) Documentation @@ -23,19 +23,19 @@ Other changes * Fixed failing unit test asset on macOS (#474) Selected dependency changes -------------- +--------------------------- * scipy >=1.5.4 (#473) Elephant 0.11.0 release notes ============================= Breaking changes -------------- +---------------- * For current source density measures electrode coordinates can no longer be supplied via a `RecordingChannelGroup` object as it is no longer supported in Neo v0.10.0 (#447) New functionality and features -------------- +------------------------------ * Redesigned `elephant.spike_train_generation` module using classes (old API is retained for compatibility) (#416) * Added function to calculate the multitaper power spectral density estimate in `elephant.spectral` (#417) @@ -44,7 +44,7 @@ New functionality and features * Support for the new `SpikeTrainList` object of Neo (#447) Bug fixes -------------- +--------- * Issue with unit scaling in `BinnedSpikeTrain` (#425) * Changed `BinnedSpikeTrain` to support quantities<0.12.4 (#418) @@ -79,7 +79,7 @@ Other changes Selected dependency changes -------------- +--------------------------- * nixio >= 1.5.0 * neo >= 0.10.0 * python >= 3.7 @@ -123,8 +123,7 @@ Bug fixes Elephant 0.9.0 release notes -**************************** - +============================ This release is titled to accompany the [2nd Elephant User Workshop](https://www.humanbrainproject.eu/en/education/participatecollaborate/infrastructure-events-trainings/2nd-elephant-user-workshop/) Viziphant @@ -189,10 +188,8 @@ Bug fixes - surrogates get arbitrary sampling_rate (https://github.com/NeuralEnsemble/elephant/pull/353), which relates to the provenance tracking issue; - Elephant 0.8.0 release notes -**************************** - +============================ New features ------------ * The `parallel` module is a new experimental module (https://github.com/NeuralEnsemble/elephant/pull/307) to run python functions concurrently. Supports native (pythonic) ProcessPollExecutor and MPI. Not limited to Elephant functional. @@ -218,7 +215,7 @@ Breaking changes * Naming convention changes (`binsize` -> `bin_size`, etc.) in almost all Elephant functions (https://github.com/NeuralEnsemble/elephant/pull/316). Elephant 0.7.0 release notes -**************************** +============================ Breaking changes ---------------- @@ -264,7 +261,7 @@ Performance Elephant 0.6.4 release notes -**************************** +============================ This release has been made for the "1st Elephant User Workshop" (https://www.humanbrainproject.eu/en/education/participatecollaborate/infrastructure-events-trainings/1st-elephant-user-workshop-accelerate-structured-and-reproducibl). @@ -296,7 +293,7 @@ Improvements Elephant 0.6.3 release notes -**************************** +============================ July 22nd 2019 The release v0.6.3 is mostly about improving maintenance. @@ -319,7 +316,7 @@ Other changes * Single VERSION file (https://github.com/NeuralEnsemble/elephant/pull/231) Elephant 0.6.2 release notes -**************************** +============================ April 23rd 2019 New functions @@ -334,7 +331,7 @@ Other changes Elephant 0.6.1 release notes -**************************** +============================ April 1st 2019 New functions @@ -352,7 +349,7 @@ Other changes Elephant 0.6.0 release notes -**************************** +============================ October 12th 2018 New functions @@ -370,7 +367,7 @@ Other changes Elephant 0.5.0 release notes -**************************** +============================ April 4nd 2018 New functions @@ -390,7 +387,7 @@ Other changes Elephant 0.4.3 release notes -**************************** +============================ March 2nd 2018 Other changes @@ -400,7 +397,7 @@ Other changes Elephant 0.4.2 release notes -**************************** +============================ March 1st 2018 New functions @@ -426,7 +423,7 @@ Other changes Elephant 0.4.1 release notes -**************************** +============================ March 23rd 2017 Other changes @@ -435,7 +432,7 @@ Other changes Elephant 0.4.0 release notes -**************************** +============================ March 22nd 2017 New functions @@ -461,7 +458,7 @@ Other changes Elephant 0.3.0 release notes -**************************** +============================ April 12st 2016 New functions @@ -490,7 +487,7 @@ Other changes Elephant 0.2.1 release notes -**************************** +============================ February 18th 2016 Other changes @@ -499,7 +496,7 @@ Minor bug fixes. Elephant 0.2.0 release notes -**************************** +============================ September 22nd 2015 New functions From 7034d9b633e95c154418d345f3e23f456dbe3f3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Oliver=20Klo=C3=9F?= <71876880+kloss-o@users.noreply.github.com> Date: Wed, 27 Apr 2022 07:58:17 +0200 Subject: [PATCH 61/63] Fix/spike train dissimilarity (#482) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * added a test that compares the victor_purpura_distance results to the results of the oroginal matlab implementation Co-authored-by: Oliver Kloß --- .../test/test_spike_train_dissimilarity.py | 63 ++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/elephant/test/test_spike_train_dissimilarity.py b/elephant/test/test_spike_train_dissimilarity.py index 5632bbbd0..4059c420c 100644 --- a/elephant/test/test_spike_train_dissimilarity.py +++ b/elephant/test/test_spike_train_dissimilarity.py @@ -5,7 +5,6 @@ :copyright: Copyright 2014-2022 by the Elephant team, see `doc/authors.rst`. :license: Modified BSD, see LICENSE.txt for details. """ - import unittest from neo import SpikeTrain import numpy as np @@ -16,6 +15,8 @@ import elephant.spike_train_generation as stg import elephant.spike_train_dissimilarity as stds +from elephant.datasets import download_datasets, ELEPHANT_TMP_DIR + class TimeScaleDependSpikeTrainDissimMeasures_TestCase(unittest.TestCase): def setUp(self): @@ -382,6 +383,66 @@ def test_victor_purpura_algorithm_comparison(self): stds.victor_purpura_distance([self.st21, self.st22, self.st23], self.q3, algorithm='intuitive')) + def test_victor_purpura_matlab_comparison_float(self): + + repo_path =\ + r"unittest/spike_train_dissimilarity/victor_purpura_distance/data" + + files_to_download = [ + ("times_float.npy", "ed1ff4d2c0eeed4a2b50a456803656be"), + ("matlab_results_float.npy", "a17f049e7ad0ddf7ca812e86fdb92646")] + + for filename, checksum in files_to_download: + download_datasets(repo_path=f"{repo_path}/{filename}", + checksum=checksum) + + times_float = np.load(ELEPHANT_TMP_DIR / 'times_float.npy') + mat_res_float = np.load(ELEPHANT_TMP_DIR / 'matlab_results_float.npy') + + r_float = SpikeTrain(times_float[0], units='ms', t_start=0, + t_stop=1000 * ms) + s_float = SpikeTrain(times_float[1], units='ms', t_start=0, + t_stop=1000 * ms) + t_float = SpikeTrain(times_float[2], units='ms', t_start=0, + t_stop=1000 * ms) + + vic_pur_result_float = stds.victor_purpura_distance( + [r_float, s_float, t_float], + cost_factor=1.0 / ms, kernel=None, + sort=True, algorithm='intuitive') + + assert_array_almost_equal(vic_pur_result_float, mat_res_float) + + def test_victor_purpura_matlab_comparison_int(self): + + repo_path =\ + r"unittest/spike_train_dissimilarity/victor_purpura_distance/data" + + files_to_download = [ + ("times_int.npy", "aa1411c04da3f58d8b8913ae2f935057"), + ("matlab_results_int.npy", "7edd32e50edde12dc1ef4aa5f57f70fb")] + + for filename, checksum in files_to_download: + download_datasets(repo_path=f"{repo_path}/{filename}", + checksum=checksum) + + times_int = np.load(ELEPHANT_TMP_DIR / 'times_int.npy') + mat_res_int = np.load(ELEPHANT_TMP_DIR / 'matlab_results_int.npy') + + r_int = SpikeTrain(times_int[0], units='ms', t_start=0, + t_stop=1000 * ms) + s_int = SpikeTrain(times_int[1], units='ms', t_start=0, + t_stop=1000 * ms) + t_int = SpikeTrain(times_int[2], units='ms', t_start=0, + t_stop=1000 * ms) + + vic_pur_result_int = stds.victor_purpura_distance( + [r_int, s_int, t_int], + cost_factor=1.0 / ms, kernel=None, + sort=True, algorithm='intuitive') + + assert_array_equal(vic_pur_result_int, mat_res_int) + def test_van_rossum_distance(self): # Tests of distances of simplest spike trains self.assertEqual(stds.van_rossum_distance( From 6ed3cb3089783035885e2fbec1fff535df7369cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristiano=20K=C3=B6hler?= <42555442+kohlerca@users.noreply.github.com> Date: Thu, 28 Apr 2022 17:23:11 +0200 Subject: [PATCH 62/63] Fixed MANIFEST.in to include CUDA/OpenCL sources when installing (#483) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristiano Köhler --- MANIFEST.in | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MANIFEST.in b/MANIFEST.in index f6dce7248..a9001a952 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -9,6 +9,8 @@ include elephant/current_source_density_src/test_data.mat include elephant/spade_src/LICENSE include elephant/spade_src/src/fim.cpp recursive-include elephant/spade_src/include *.h +include elephant/asset/*.cu +include elephant/asset/*.cl include elephant/test/spike_extraction_test_data.txt recursive-include doc * prune doc/_build From 0df45812b93229b3186c061cb84ec29fd380e09c Mon Sep 17 00:00:00 2001 From: Moritz Kern <92092328+Moritz-Alexander-Kern@users.noreply.github.com> Date: Fri, 20 May 2022 16:06:09 +0200 Subject: [PATCH 63/63] fix Issue #481, ASSET tries to use a backend that is not present in the environment (#485) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * added coverage to MPI runner, removed MPI from pip added function get_opencl_capability() to utils, to detect openCL devices * updated docstring, changed return logic * added unittest, regression Issue #481 Co-authored-by: Cristiano Köhler --- elephant/asset/asset.py | 6 ++++-- elephant/test/test_asset.py | 35 ++++++++++++++++++++++++++++++++++- elephant/utils.py | 22 ++++++++++++++++++++++ 3 files changed, 60 insertions(+), 3 deletions(-) diff --git a/elephant/asset/asset.py b/elephant/asset/asset.py index 7a28089b5..7382718ba 100644 --- a/elephant/asset/asset.py +++ b/elephant/asset/asset.py @@ -136,7 +136,7 @@ import elephant.conversion as conv from elephant import spike_train_surrogates -from elephant.utils import get_cuda_capability_major +from elephant.utils import get_cuda_capability_major, get_opencl_capability try: from mpi4py import MPI @@ -513,9 +513,11 @@ def _choose_backend(self): use_cuda = int(os.getenv("ELEPHANT_USE_CUDA", '1')) use_opencl = int(os.getenv("ELEPHANT_USE_OPENCL", '1')) cuda_detected = get_cuda_capability_major() != 0 + opencl_detected = get_opencl_capability() + if use_cuda and cuda_detected: return self.pycuda - if use_opencl: + if use_opencl and opencl_detected: return self.pyopencl return self.cpu diff --git a/elephant/test/test_asset.py b/elephant/test/test_asset.py index 0962c5844..9a1f00f5a 100644 --- a/elephant/test/test_asset.py +++ b/elephant/test/test_asset.py @@ -33,7 +33,7 @@ try: import pyopencl - HAVE_PYOPENCL = True + HAVE_PYOPENCL = asset.get_opencl_capability() except ImportError: HAVE_PYOPENCL = False @@ -393,6 +393,39 @@ def test_intersection_matrix(self): spiketrains_i=[st1, st2], bin_size=bin_size, t_stop_j=5 * pq.ms) + # regression test Issue #481 + # see: https://github.com/NeuralEnsemble/elephant/issues/481 + def test_asset_choose_backend_opencl(self): + class TestClassBackend(asset._GPUBackend): + + def __init__(self): + super().__init__() + self.backend = self._choose_backend() + + def cpu(self): + return "cpu" + + def pycuda(self): + return "cuda" + + def pyopencl(self): + return "opencl" + + # check which backend is chosen if environment variable for opencl + # is not set + os.environ.pop('ELEPHANT_USE_OPENCL', None) + # create object of TestClass + backend_obj = TestClassBackend() + + if HAVE_PYOPENCL: + self.assertEqual(backend_obj.backend(), 'opencl') + else: + # if environment variable is not set and no module pyopencl or + # device is found: choose cpu backend + self.assertEqual(backend_obj.backend(), 'cpu') + + os.environ['ELEPHANT_USE_OPENCL'] = '0' + @unittest.skipUnless(HAVE_SKLEARN, 'requires sklearn') class TestJSFUniformOrderStat3D(unittest.TestCase): diff --git a/elephant/utils.py b/elephant/utils.py index 3ce1e9206..f634a570a 100644 --- a/elephant/utils.py +++ b/elephant/utils.py @@ -340,3 +340,25 @@ def get_cuda_capability_major(): ctypes.byref(cc_minor), device) return cc_major.value + + +def get_opencl_capability(): + """ + Return a list of available OpenCL devices. + + Returns + ------- + bool + True: if openCL platform detected and at least one device is found, + False: if OpenCL is not found or if no OpenCL devices are found + """ + try: + import pyopencl + platforms = pyopencl.get_platforms() + + if len(platforms) == 0: + return False + # len(platforms) is > 0, if it is not == 0 + return True + except ImportError: + return False