Annarchy

Latest version: v4.7.3

Safety actively analyzes 630360 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 6 of 9

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.

Page 6 of 9

© 2024 Safety CLI Cybersecurity Inc. All Rights Reserved.