SpikingInputNeuron.cpp

Go to the documentation of this file.

#include "SpikingInputNeuron.h"

#include <algorithm>
using std::sort;
using std::transform;
using std::copy;
using std::equal;
using std::insert_iterator;
using std::unique;

#include <iostream>
using std::cout;
using std::endl;

SpikingInputNeuron::SpikingInputNeuron() : SingleOutputSpikeSender(), sorted(false)
{
    /* NOOP */
}

SpikingInputNeuron::SpikingInputNeuron(const std::vector<double> &spikeTimes) : SingleOutputSpikeSender(),
        spikeTimes(spikeTimes), sorted(false)
{
}

class quantifier
{
public:
    quantifier( double quant ) : _quant(quant)
    {}
    ;

    double operator() ( double v)
    {
        return ((int)(v / _quant)) * _quant;
    }

    double _quant;
};

void SpikingInputNeuron::adjustSpikesToTimeGrid( double dt )
{
        transform( spikeTimes.begin(), spikeTimes.end(), spikeTimes.begin(), quantifier( dt ) );
}

void SpikingInputNeuron::sort_spikes()
{
    // first quantify the spikes to be multiples of DT
    sort( spikeTimes.begin(), spikeTimes.end() );
    spikeTimes.erase( unique<std::vector<double>::iterator>(spikeTimes.begin(), spikeTimes.end()), spikeTimes.end() ) ;
    sorted = true;
}


void SpikingInputNeuron::setSpikes(const std::vector<double> &theSpikeTimes)
{
    spikeTimes = theSpikeTimes;
    sorted = false;
}

const std::vector<double> &SpikingInputNeuron::getSpikeTimes() const
{
        return spikeTimes;
}

void SpikingInputNeuron::addSpike( double st, bool force_sort )
{
    spikeTimes.push_back( st );
    sorted = false;
}

int SpikingInputNeuron::reset( double dt )
{
    SingleOutputSpikeSender::reset();

    if( ! sorted ) {
        sort_spikes();
    }

    currentStep = nextSpikeIdx = 0;
    numStepsToNextSpike = -1;
    if( spikeTimes.size() > nextSpikeIdx ) {
        numStepsToNextSpike = (long)( -0.001 * dt + spikeTimes[ nextSpikeIdx ] / dt );
    }
    return 0;
}

int SpikingInputNeuron::reset( double dt, double startT)
{
        if( ! sorted ) {
                sort_spikes();
        }

        currentStep = long(startT / dt);
        nextSpikeIdx = 0;
    if( spikeTimes.size() > nextSpikeIdx ) {
        numStepsToNextSpike = (long)( -0.001 * dt + spikeTimes[ nextSpikeIdx ] / dt - currentStep );
    }
        return 0;
}


int SpikingInputNeuron::advance(AdvanceInfo const &ai)
{
    currentStep++;
    if( ( spikeTimes.size() > nextSpikeIdx ) && ( numStepsToNextSpike-- == 0 ) ) {
        nextSpikeIdx++;
        numStepsToNextSpike = -1;
        if( spikeTimes.size() > nextSpikeIdx ) {
            numStepsToNextSpike = (long)( ( -0.001 * ai.dt.in_sec() + spikeTimes[ nextSpikeIdx ] ) / ai.dt.in_sec() ) - currentStep ;
        }
        out_port.setSpike( ai, spikeTimes[ nextSpikeIdx-1 ] );
        return ADVANCEFLAG_HASSPIKED;
    } else {
        return 0;
    }
}

void SpikingInputNeuron::printSpikeTimes()
{
    for( size_t i=0; i<spikeTimes.size(); i++) {
        cerr << spikeTimes[i] << " ";
    }
    cerr << endl;
}

---