**4.7.1.4**

* `reset()` has a new argument *monitors* to control the clearing of monitored results.
* Improved error messages for non-implemented features on CUDA devices.
* Bugfixes:
    * fixed bugs related to compuation of mean-firing rate for spiking models.
    * fixed a bug related to IndividualNeuron accessor.

**4.7.1.3**

* Extended the available set of hand-written SpMV codes (in particular SSE and AVX-512)
* Bugfixes:
    * the usage of storage_format="dense" and a constant weight (e.g. in the COBA example) leads to an error message.
    * Network.enable_learning() had no period/offset arguments.
    * TypeError occured in connect_fixed_number_post() cause by a type mismatch on a temporary variable.

**4.7.1.2**

* Bugfixes:
    * Handling of non-uniform delays in connect_with_func 
    * Added Monitor.reset() to reinitialize monitors. Called automatically by reset().

**4.7.1.1**

* Changed default compiler flags used by ANNarchy:
   * cython modules build during setup.py use only `-O3`
   * c++ (model compile) default flags are now: `-O3 -ffast-math -fno-finite-math-only -march=native` (following Brian2 default flags)
* Improved automatic format selection for rate-coded models (experimental, we greatly appreciate bug reports).
* HomogeneousCorrelatedSpikeTrains: `corr` can now be a single value.
* TimedPoissonPopulation: `rates` can now be a single value.

* Bugfixes:
   * Monitor: fixed start and stop times.
   * CUDA: device configuration (annarchy.json) was ignored.

**4.7.1**

* Automatic format selection for rate-coded models (experimental, we greatly appreciate bug reports).
* Bugfixes for data structures introduced in 4.7.0.
* Improved code generation, e. g. AVX instructions for default psp of rate-coded models, added dense matrices for spiking models.

**4.7.0.2**

* Support for Apple M1 processors.
* Bugfix (openMP): the spike generation of SpikeSourceArray was not implemented correctly for multiple threads.

**4.7.0.1**

* Replaced deprecated numpy.random.random_integers by numpy.random.randint
* Added openMP support for BOLD monitor extension.
* Bugfix: in some cases projection variables were not stored/load correctly (indicated by an error message).

**4.7.0**

* Added a `bold` monitoring extension allowing to transform neural activity into a BOLD signal according to a computational model (e.g. the Balloon model).
* Added a ``Transpose`` projection.
* Replaced use of random package by numpy.random.
* Calling `clear()` in a notebook is fixed.
* Many improvements under the hood: code refactoring, new data structures (ELLPACK-R, CSRC), speed improvements, etc. 


**4.6.10.1**

* Monitoring projections failed when the post-synaptic projection was a PopulationView not starting at 0.
* Bugfixes on CUDA:
   * for higher order numerical methods (midpoint) the RNGs need to be drawn outside the update method.
   * if a projection between spiking neurons was targeting two channels (e. g. ampa and nmda), a wrong code was generated.

**4.6.10**

* Moved the documentation to mkdocs: https://github.com/ANNarchy/ANNarchy.github.io
* Added a ``TimedPoissonPopulation`` allowing to schedule the rate.
* ``HomogeneousCorrelatedSpikeTrains`` can also take a schedule for rates and corr.
* Python 2 has been depreciated. 
* Fixed bugs related to cython, colab, sympy 1.6.1.

**4.6.9**

* The ``tensorboard`` extension allows to log various infos and visualize them using tensorboard.
* The API of the ``convolution`` extension has slightly changed, check the documentation.
* Changed default behavior from the built-in Izhikevich neuron model from fast spiking to regular spiking.
* ``PopulationView.rank_from_coordinates`` and ``PopulationView.coordinates_from_rank`` now accept coordinates relative to the geometry of the popview using the ``local`` flag.
* Fixed installation on Anaconda distributions. Now works in colab with ``!pip install ANNarchy``.
* Several bug fixes (variable-dependent refractory periods, conditionals of the type  "if (t==1)", SpikeSourceArray, etc).
* Improved performance with CUDA.

**4.6.8.1**

* MacOS compatibility.
* Bugfix on ``Projection.load()``.

**4.6.8**

* ``SpikeSourceArray`` can now receive connections (which will be ignored, but may be used to investigate plasticity mechanisms).
* Added a ``clear_all_callbacks()`` method when using @every.
* Added a `CurrentInjection` population allowing to connect a rate-coded population to the conductance of a spiking population.
* Several bug fixes and improvements.


**4.6.7**

* Feature: delays can now be changed after ``compile()``, even if the maximum delay is higher than before.
* Improved performance for spiking networks with variable delays through the use of ring buffers.
* Improved control of single/double precision.
* Improved performance on GPUs.
* Fixed bug when SpikeSourceArray, TimedArray and HomogeneousCorrelatedSpikeTrains were used inside a network or parallel_run().
* Fixed bug when using different seeds in ``parallel_run()``.
* Global functions defined by ``add_function()`` were not available on CUDA devices.
* The use of ``dendrite.rank`` is deprecated, use ``dendrite.pre_ranks`` instead.
* GPU hardware detection has been improved.

**4.6.6**

* Issue #55: Populations and projections can now save/load their variables into/from Numpy `.npz` files instead of pickled binary text files.
* Bugfix (CUDA): modified transmission flag was ignored on projections.
* Bugfix: memory leak when using Monitors in parallel_run().
* Added raster_plot, histogram and so on outside the monitor for offline analysis.
* Improvements on memory management.

**4.6.5**

* Monitor: added new argument ``period_offset`` to define the offset within a period to record. The default argument is 0ms to match the previous behavior (at the beginning of the period).
* Issue 54: when generating a report, possible subfolders are created before writing the report file
* CUDA now supports usage of post.sum() respectively pre.sum() in synaptic equations.
* CUDA ``SpikeSourceArray``: wrong update of events on the GPU device led to wrong results.
* Various bug fixes and improvements.

**4.6.4**

* Merged pull request by @ilysym to improve OpenMP efficiency. Thanks Ilya!
* Added a ``power(x,a)`` function to replace the slow cmath pow(x,a) function
* Added accessors to ANNarchy.core.Network to allow access to all populations/projections assigned to a Network
* Various bug fixes and improvements.

**4.6.3**

* ``pre_spike`` and ``post_spike`` fields of a spiking neuron can now modify pre and post synaptic variables::

    pre_spike = """
        g_target += w
        post.nb_spikes += 1
    """

* ``SpikeSourceArray`` available on CUDA.
* ``Monitor.mean_fr()`` and ``Monitor.histogram()`` now work with PopulationViews (thanks @ilysym).
* Many bug fixes with Python3 and CUDA.


**4.6.2**

* Rate-coded neurons can now use ``sum()`` to sum over all targets, instead of specifying them.
* ``Constant`` objects can now be created to define global-level parameters which do not need to be explicitly defined in Neurons/Synapses.
* Parameter definitions can use constants. Note that changing the constant after compilation does not change the parameter.
* The initial value of a variable (``init=``) can use constants instead of numerical values.
* ``report()`` has been improved and can now generate Markdown reports, which can be converted to html or pdf by pandoc.

**4.6.1**

* Issue 44: The performance of spiking networks with CUDA has been improved.
* ``Population.compute_firing_rate`` can now be called anytime to change the window over which the mean firing rate of a spiking neuron is computed.
* The performance of the exponential numerical method has been improved by computing the step size outside the loop (when possible).
* Mean-firing rate computation is now available for CUDA devices (slow!).
* Issue 43: the path to the CUDA installation can now be set in a config file at ``~/.config/ANNarchy/annarchy.json``.
* Simulations on GPU can be started on the command line by using ``--gpu`` or ``--gpu=2`` if you have multiple GPUs.

**4.6.0**

* CUDA implementation for rate-code networks revised and fixed several errors.
* CUDA now supports now the simulation of spiking neurons (please refer to the documentation to discover limitations).
* CUDA allows now the monitoring of dendrites.
* Added the command line argument --cuda to run simulations on CUDA devices.
* Issue 38: user-defined functions are now available in user space::

    add_function('sigmoid(x) = 1.0 / (1.0 + exp(-x))')

    compile()

    x = np.linspace(-10., 10., 1000)
    y = functions('sigmoid')(x)

* Major reimplementation of data structures for the connectivity patterns (LIL, CSR).
* Added the ``TimedArray`` population to store the temporal evolution of a population's firing rate internally. See :doc:`../manual/Inputs`.
* Fixed structural plasticity and added an example in ``examples/structural_plasticity``.
* Added the ``projection`` keyword allowing to declare a single parameter/variable for the whole projection, instead of one value per synapse (the default) or one value per post-synaptic neuron (keyword ``postsynaptic``).
* Parameters can now also be recorded by Monitors.
* Projections can now be monitored, if the user knows what he does...
* The global parameters of populations and projections can now be saved/loaded to/from a JSON file for manual parameterization.
* Many bug fixes.
* Deprecated recording functions and objects such as ``RateNeuron`` are removed.

**4.5.7**

* Sympy 1.0 introduced a regression to the != operator.
* Issue 30: PopulationViews had a bug hen modifying variables on a multidimensional population.
* Issue 33: connect_one_to_one now accepts any kind of popview (even with random indices), as long as they have the same size.
* Issue 33: recording spikes on popviews did not work correctly.
* The normal distribution is fixed in CUDA.
* Delays are now rounded to the next multiple of dt, not cast into a int (i.e. 1.99 is now 2, not 1 with dt=1.0).
* SpikeSourceArray is now tolerant to very high firing schedules.

**4.5.6**

* Spiking networks can now use variable delays, at the cost of extra computations.
* Fixed bug in parser when a synapse uses pre/post variables with one name containing the other (e.g. r and r_mean).
* Fixed bug when assigning postsynptic variable a random distribution.
* Added the ability to access the weighted sums of a rate-coded population with::

    pop.sum('exc')

* Added the ability to record these weighted sums::

    m = monitor(pop, ['r', 'sum(exc)'])


**4.5.5**

* Fixed bug when loading a network saved before 4.5.3.
* Added the ``every`` decorator allowing functions to be called periodically during a simulation::

    result = []

    @every(period=1000.)
    def set inputs(n):
        # Set inputs to the network
        pop.I = Uniform(0.0, 1.0)
        # Save the output of the previous step
        result.append(pop.r)

    simulate(100 * 1000.)

* Fixed installation with non-standard Python distribution (e.g. Anaconda).
* Added a ``HomogeneousCorrelatedSpikeTrains`` class allowing to generate homogeneous correlated spike trains::

    pop = HomogeneousCorrelatedSpikeTrains(geometry=200, rates=10., corr=0.3, tau=10.)

* Installing through pip does not forget CUDA files anymore.
* Added ``Population.clear()`` to clear all spiking events (also delayed) without resetting the network.
* ``Population.reset()`` and ``Projection.reset()`` now accept a list of attributes to be reset, instead of resetting all of them.
* Unit tests are now performed on Travis CI to get a badge.
* Bug fixed: min/max bounds on g_target was wrongly analyzed when depending on a parameter.
* ``parallel_run()`` now accepts additional arbitrary arguments that can be passed to the simulation callback.
* Added an ``ite(cond, statement1, statement2)`` conditional function replicating ``if cond: statement1 else: statement2``, but which can be combined::

    r = 1.0 + ite(sum(exc) > 1.0, sum(exc), 0.0) + ite(sum(inh) > 1.0, -sum(inh), 0.0)

* The ``Network`` class has several bugs fixed (e.g. disabled populations stay disabled when put in a network).
* Populations have now an "enabled" attribute to read their status.


**4.5.4:**

* Spiking neurons now define the variable ``t_last`` storing the time (in ms) of the last emitted spike.
* Added a method ``compute_firing_rate()`` that allows spiking neurons to compute their mean firing rate over a prefined window and store the result (in Hz) into the reserved variable ``r``.
* Fixed bug when using "if a == b".
* Pre- and post-synaptic occuring at the same time are now both evaluated. The flag ``unless_post`` can be set in ``pre_spike`` to disable the evaluation of the pre-spike in that case (default behavior for simple_stdp example).
* Fixed code generation for MacOS X, especially when using a non-standard Python installation (e.g. anaconda).
* ``compile()`` now accepts a different compiler (g++ or clang++) and custom flags.
* Now works correctly in ipython notebooks.
* Added iPython notebooks to the examples.
* Fixed the ``load()`` method when using a single weight, or for very sparse random projections.

**4.5.3:**

* Projections can be assigned a name.
* A list or Numpy array can be used to slice a Population::

    neurons = [1, 4, 17, 34]
    subpop = pop[neurons]

* Synapses can be accessed directly at the Projection level with::

    proj.synapse(pre, post) # equivalent to proj[post][pre]

* Bugfix: pop[0] now returns a PopulationView containing the neuron 0, not an IndividualNeuron (accessible through pop.neuron(0))
* Various bugfixes in CUDA.
* Bugfix: connect_from_sparse now works with popviews whose ranks are not linearly increasing (e.g. columns)
* Bugfix: IO access to projection data should now be much faster.
* Spiking neurons can have delayed variables.

**4.5.2:**

* Fixed save/load methods
* parallel_run() has now control over the seeds.
* report(): fixed nested conditionals and power functions
* Synaptic transmission can be stopped using proj.transmission = False
* Synaptic update can be disabled using proj.update = False
* Synaptic plasticity can be disabled using proj.plasticity = False
* enable_learning() accepts period and offset arguments.

**4.5.1:**

* Fixed compilation on MacOSX
* Fixed compatibility with Python 3.4
* Refactoring of the generation templates
* Fixed bug introduced by Sympy 0.7.6
* Multiple blocks of ODEs and assignments can now be used in the equations field.
* Parser simplified
* Dense all-to-all connectivity matrices use indices instead of vectors, improves performance.
* Projections initialized with a single weight value and without plasticity now use a double for the weight instead of vector<vector<double>>
* Regression on get_record(reshape=True) fixed.
* CUDA backend improved.
* parallel_run() now uses the minimum between the number of available cores and the total number of networks.
* Several bugs in report.


**4.5.0:**

* A ``Network`` object has been added to run multiple simulations in parallel (``parallel_run()``). See :doc:`../manual/Network`.
* Recording goes through the ``Monitor`` object. Old recording methods are depreciated. See :doc:`../manual/Recording`.
* The flag ``exact`` is replaced by ``event-driven``. Still works, but will be suppressed in future versions.
* The behavior of a spiking neuron with two coupled variables (e.g. Izhikevich) during the refractory period is changed. The ODEs are not evaluated at all during the refractory period (except the conductances). The ``unless-refractory`` flag has no effect anymore. Before, ``u`` started decaying during the refractory period.
* Variables updated in pre-spike or post-spike (spiking synapse) can now define min/max bounds. Useful to avoid clipping explicitly the weights.
* Change in hybrid populations. ``PoissonPopulation`` should be used for rate-to-spike conversion, ``DecodingProjection`` for spike-to-rate. See :doc:`../manual/Hybrid`.
* Bug when using conditionals in pre-spike and post-spike.
* Bug when using t_pre and t_post explicitly.
* Speed-up of connect_fixed_number_pre/post.

**4.4.0:**

* Experimental support for CUDA backend for rate-coded networks.
* Any pre-synaptic variable can be delayed if used in the synapse.
* ``g_target`` can define min/max flags.
* Support for MacOS X.
* Parallel performance for OpenMP and spiking networks improved.
* Sequential code (1T) does not use OMP.
* psp argument can use global operations and global variables.
* Added ``connect_from_sparse()`` method.

**4.3.5:**

* Small bug fixes.

**4.3.4:**

* Automatic reporting is added.
* Several bug fixes.
* The distinction between Rate- and SpikeNeuron objects is deprecated, use Neuron instead.
* The distinction between Rate- and SpikeSynapse objects is deprecated, use Synapse instead.


**4.3.3:**

* Structural plasticity can be defined at the synaptic level.

**4.3.2:**

* Random distributions are available in synapses.
* Populations can be momentarily disabled/enabled.
* Recording can be done with a given period instead of every time step.
* Different modes for Spike2Rate conversion.
* Extension for shared projections (convolution/pooling) improved.

**4.3.1:**

* CUDA implementation for rate-coded networks with small restrictions.
* Weight-sharing for convolutions and pooling.
* Possibility to create projections using a dense connection matrix or data saved in a file.
* A seed can be defined for the random number generators.

**4.3.0:**

* Simplified internal structure for the generated code.
* Major speed-up for compilation and execution times.
* Rate-coded projections can perform other functions than sum (min/max/mean) over the connected synapses.

**4.2.4:**

* Neuron and Synapse replace RateNeuron, SpikeNeuron, RateSynapse, SpikeSynapse in the main interface (kept for backward compatibility).
* Default PyNN neural models are now available (Izhikevich, IF_curr_exp, IF_cond_exp, IF_curr_alpha, IF_cond_alpha, HH_cond_exp, EIF_cond_alpha_isfa_ista, EIF_cond_exp_isfa_ista).
* Bug fixes for delays and spike propagation.
* Connectivity matrices (CSR) are more efficient.
* Several PyNN examples are added to the examples/ folder.

**4.2.3**

* Spike conditions can depend on several variables.
* The midpoint numerical method is added.
* Ability to choose globally the numerical method.

**4.2.2**

* The Euler implicit method is added.
* Systems of equations are now solved concurrentely.

**4.2.1:**

* Early-stopping of simulations (simulate_until).

**4.2.0:**

* Added hybrid populations (Spike2RatePopulaton, Rate2SpikePopulation).
* Individual save/load of populations and projections.
* PopulationViews can be used to build Projections.
* CSR objects are simplified.
* Default conductance behaviour (g_target = 0.0).
* Random distribution objects can take global parameters as arguments.
* min and max bounds can depend on other variables.
* Logical operators (and, or..) can be used in conditions.

**4.1.2:**

* Rate-coded neurons must output "r", not "rate". Synapses must use "w", not "value".
* Synapses can access pre-synaptic weighted sums (pre.sum(exc)).
* Created PoissonPopulation.

**4.1.1:**

* Connectivity matrices are now created in Cython.
* Recording methods have changed.
* Spiking neurons have a refractory period.
* Added clip() functions for semi-linear transfer functions.
* Added smoothed_firing_rate() method for visualizing spiking networks.

**4.1.0:**

* First stable release with both rate-coded and spiking networks.