Spiking neural networks are artificial neural networks mimicking the operation of real neural circuits. Unlike classical artificial neural networks, these spiking neural networks encode the input and output information through trains of impulses over time (spikes). The neurons composing these networks are thus simulated over time, and the state of each of these neurons is repeatedly updated during the simulation. Depending on the desired degree of realism these neurons may be implemented through complex mathematical models reproducing the output of particular neurons of the nervous system fairly faithfully.

EDLUT (Event-Driven LookUp-Table simulator) is one of the fastest simulators of realistic spiking neural networks running in a conventional PC. This speed saves the experimenter time and enables the real-time simulation of medium-size networks, which can be exploited in real-time experiments such as the control of a real robotic arm. This simulation speed-up is achieved by means of combining time-driven (in GPU) and event-driven (in CPU) simulation methods.

## Time-driven simulation

This is the most popular and straightforward simulation method for spiking neural networks. If this method is employed, the simulation time is divided into small time steps. After each time step the state of all neurons are updated, their inputs are evaluated and the corresponding neuron output is generated. The shorter the time step is, the greater the output precision is and the slower the simulation becomes. The neuron state usually comprises a set of internal variables such as the neuron membrane potential (Vm). Usually the more complex the neuron model is, the larger the variable set is.

### Variable-time-step time-driven simulation

When the neuron state do not change quickly during a simulation interval the length of the time step can be increased without degrading the simulation precision significantly during this interval. Dynamically adjusting the simulation time step is referred to as variable time-step. EDLUT recently implements a variation of this method (bi-fixed-step integration) to efficiently simulate complex neuron models.

The neuron model is composed of equations that update the neuron state. Some of these equations may be differential equations that may require numerical integration to approximately calculate the updated variable value. Therefore the time-driven simulation is very convenient to calculate the solution of these differential equations, since the small-time-step updates are used to implement a numerical integration such as the Euler method. However this repetitive variable update is a time-consuming calculation that slows down the simulation.

## Even-driven simulation

The neural-network simulation does not require that the neuron state is constantly updated to calculate the neuron output. This neuron state could be updated just when the expected evolution of this state is modified, that is, when the neuron receives an input spike or when it emits an output spike. These events could be quite sparse in time, so numerical integration does not suit this simulation method. Ideally the differential equations that determine the state-variable values should be analytically integrated, and the resultant mathematical expressions could be used to update these variables after arbitrary time jumps (when an event occurs).

This method usually achieves the highest simulation speeds in CPU, especially when the neural activity is not very high.

Unfortunately there are cases where it is very difficult or impossible to analytically integrate these differential equations. In order to allow the event-driven simulation in these cases, EDLUT employs lookup tables to quickly update the state variables.

### Lookup tables for updating the neuron state

The set of equations that determines the neuron state depends on a set of independent variables: the previous neuron state, the input and the elapsed time since the previous state. So a lookup table can be used to associate the value of the new neuron state with the value of these independent variables. A large set of values of each independent variable is considered, and the new neuron state (dependent variables) is calculated for each combination of independent-variable values. The result is a large lookup table that encodes the neuron model. This time-consuming computation can be performed (before the actual network simulation) through numerical analysis if the model equations include differential equations. Once this lookup table is created it can be exploited during the simulation to quickly obtain the state of all the network neurons achieveing a very fast event-driven simulation.

Using this approach EDLUT enables the event-driven simulation of neuron models that traditionally required a time-driven simulation such as Hodgkinâ€“Huxley-type models.

EDLUT is open-source software made available with a license GNU GPL version 3.