auryn::SpikeDelay Class Reference

Delay object for spikes which is synchronized between nodes using the SyncBuffer formalism implemented in System. More...

#include <SpikeDelay.h>

Public Member Functions
	SpikeDelay (int delaysteps=MINDELAY)
	The default constructor. More...
virtual	~SpikeDelay ()
	The default destructor. More...
void	set_delay (int delay)
	Set delay in number of timesteps. More...
int	get_delay ()
	Get delay time in AurynTime. More...
void	set_clock_ptr (AurynTime *clock)
	Internal function to set clock pointer. More...
void	insert_spike (NeuronID i, AurynTime ahead)
	Allows to insert spikes so many time steps ahead with less than max delay. More...
void	insert_spike_and_attrib (NeuronID i, AurynState attr, AurynTime ahead)
	Allows to insert spikes with a single attribute so many time steps ahead with less than max delay. More...
void	push_back (NeuronID i)
	Allows to use SpikeDelay like a queue. More...
void	push_back (NeuronID i, AurynState attr)
	Like push_back, but also allows to add an attribute. More...
void	push_back (SpikeContainer *sc)
	Pushes all elemens from given SpikeContainer into the delay. More...
int	get_num_attributes ()
	Returns the number of spike attributes per spike. More...
void	inc_num_attributes (int x)
	Internally used by SyncBuffer to submit x attributes with spikes in this delay. More...
SpikeContainer *	get_spikes (unsigned int pos=1)
	Returns the spikes at a given delay position. More...
SpikeContainer *	get_spikes_immediate ()
	Returns the spikes stored into the delay within this very same time step. More...
AttributeContainer *	get_attributes (unsigned int pos=1)
	Like get_spikes but returns the spike attributes. More...
AttributeContainer *	get_attributes_immediate ()
	Like get_spikes_immediate but returns the spike attributes. More...
void	print ()
	Print delay contents for debugging . More...
void	clear ()

Friends
class	boost::serialization::access

Detailed Description

Delay object for spikes which is synchronized between nodes using the SyncBuffer formalism implemented in System.

A simple list class to store spikes (numbers of type NeuronID). Memory allocation is only done when the container needs to grow. The class never shrinks thus optimizing performance but not memory efficiency.

Constructor & Destructor Documentation

SpikeDelay()

SpikeDelay::SpikeDelay

(

int

delaysteps = MINDELAY

)

The default constructor.

{
        numSpikeAttributes = 0;
        delaybuf = NULL;
        attribbuf = NULL;
        ndelay = 0;
        set_delay(delay);
}

Here is the call graph for this function:

~SpikeDelay()

SpikeDelay::~SpikeDelay ( )

virtual

The default destructor.

{
        free();
}

Member Function Documentation

clear()

void SpikeDelay::clear

(

)

Clears all containers in delay.

{
        for (unsigned int i = 0 ; i < ndelay ; ++i) {
                delaybuf[i]->clear();
                attribbuf[i]->clear();
        }
}

get_attributes()

AttributeContainer * SpikeDelay::get_attributes

(

unsigned int

pos = 1

)

Like get_spikes but returns the spike attributes.

{
        return attribbuf[((*clock_ptr)+pos)%ndelay]; 
}

get_attributes_immediate()

AttributeContainer * SpikeDelay::get_attributes_immediate

(

)

Like get_spikes_immediate but returns the spike attributes.

{
        return get_attributes(0);
}

Here is the call graph for this function:

get_delay()

int SpikeDelay::get_delay

(

)

Get delay time in AurynTime.

{
        return ndelay;
}

get_num_attributes()

int SpikeDelay::get_num_attributes

(

)

Returns the number of spike attributes per spike.

Spike attributes are used to implement short-term plasticity or similar mechanisms efficiently.

{
        return numSpikeAttributes;
}

get_spikes()

SpikeContainer * SpikeDelay::get_spikes

(

unsigned int

pos = 1

)

Returns the spikes at a given delay position.

pos == 1 corresponds to the maximum delay of the SpikeDelay and at least to MINDELAY+1. pos == 2 corresponds to the maximum delay -1, and so forth ...

{
        return delaybuf[((*clock_ptr)+pos)%ndelay]; 
}

get_spikes_immediate()

SpikeContainer * SpikeDelay::get_spikes_immediate

(

)

Returns the spikes stored into the delay within this very same time step.

{
        return get_spikes(0);
}

Here is the call graph for this function:

inc_num_attributes()

void SpikeDelay::inc_num_attributes

(

int

x

)

Internally used by SyncBuffer to submit x attributes with spikes in this delay.

{
        numSpikeAttributes += x;
}

insert_spike()

void SpikeDelay::insert_spike	(	NeuronID	i,
		AurynTime	ahead
	)

Allows to insert spikes so many time steps ahead with less than max delay.

Parameters

i	Neuron id of the spike
ahead	Time steps in AurynTime in the future where to insert the spike in the delay

{
        get_spikes(1+ahead+ndelay)->push_back(i);
}

Here is the call graph for this function:

insert_spike_and_attrib()

void SpikeDelay::insert_spike_and_attrib	(	NeuronID	i,
		AurynState	attr,
		AurynTime	ahead
	)

Allows to insert spikes with a single attribute so many time steps ahead with less than max delay.

Parameters

i	Neuron id of the spike
attr	The spike attribute to insert
ahead	Time steps in AurynTime in the future where to insert the spike in the delay

{
        get_spikes(1+ahead+ndelay)->push_back(i);
        get_attributes(1+ahead+ndelay)->push_back(s);
}

Here is the call graph for this function:

print()

void SpikeDelay::print

(

)

Print delay contents for debugging .

{
        for ( unsigned int i = 0 ; i < ndelay ; ++i ) {
                SpikeContainer * spikes = get_spikes(i);
                if ( spikes->size() ) {
                        std::cout << "slice " << i << ": ";
                        for ( NeuronID k = 0 ; k < spikes->size() ; ++k ) {
                                std::cout << spikes->at(k) << " ";
                        }
                        std::cout << std::endl;
                }
        }
}

Here is the call graph for this function:

push_back() [1/3]

void SpikeDelay::push_back

(

NeuronID

i

)

Allows to use SpikeDelay like a queue.

This pushes into get_spikes_immediate()

{
        get_spikes_immediate()->push_back(i);
}

Here is the call graph for this function:

push_back() [2/3]

void SpikeDelay::push_back	(	NeuronID	i,
		AurynState	attr
	)

Like push_back, but also allows to add an attribute.

This pushes into get_spikes_immediate()

{
        get_spikes_immediate()->push_back(i);
        get_attributes_immediate()->push_back(attr);
}

Here is the call graph for this function:

push_back() [3/3]

void SpikeDelay::push_back

(

SpikeContainer *

sc

)

Pushes all elemens from given SpikeContainer into the delay.

This pushes into get_spikes_immediate()

{
        for ( NeuronID i = 0 ; i < sc->size() ; ++i ) {
                push_back(sc->at(i));
        }
}

Here is the call graph for this function:

set_clock_ptr()

void SpikeDelay::set_clock_ptr

(

AurynTime *

clock

)

Internal function to set clock pointer.

Sets internal clock pointer to system wide clock pointer. It is used by the System class

{
        SpikeDelay::clock_ptr = clock;
}

set_delay()

void SpikeDelay::set_delay

(

int

delay

)

Set delay in number of timesteps.

This allows to set the size of the delay in timesteps. The delay has to be at least of size MINDELAY.

{
        if ( delay+1 == ndelay ) return; // we already have the right delay

        if ( delaybuf ) free(); // we have to free the old delay

        // and now create the new delay
        ndelay = delay+1;
        delaybuf = new SpikeContainer * [ndelay] ;
        attribbuf = new AttributeContainer * [ndelay] ;
        for (int i = 0 ; i < ndelay ; ++i) {
                delaybuf[i] = new SpikeContainer( );
                attribbuf[i] = new AttributeContainer( );
        }
}

Friends And Related Function Documentation

boost::serialization::access

friend class boost::serialization::access

friend

---

The documentation for this class was generated from the following files:

• /home/zenke/auryn/src/auryn/SpikeDelay.h
• /home/zenke/auryn/src/auryn/SpikeDelay.cpp