Neuron.h

Go to the documentation of this file.

#ifndef __NEURON_H
#define __NEURON_H

#include <set>
#include <map>
#include <string>

#include <an/Random.h>

#include "../../utils/Graph.h"
#include "../../utils/SpikeDelayLine.h"

namespace Teem
{
    class Synapse;
    
    class Neuron
    {
    public:
        typedef std::set<Synapse*> SynapseSet;
        
        SynapseSet incoming; 
        SynapseSet outgoing; 
        TagSet tags; 
    
    public:
        Neuron();
        virtual ~Neuron();
        
        virtual void finalize() { }
    
        virtual bool getSpike() const {return lastSpike;}
        virtual double getCurrent() const {return lastCurrent;}
    
        virtual void setParams(const std::map<std::string, double> params);
        virtual void setParams(const std::string &param, double value);
        
        
        virtual void update(double dt = 1.0) = 0;
        virtual void commit() = 0;
    
    protected:
        bool lastSpike;
        double lastCurrent;
    
    };
    
    class InputNeuron : public Neuron
    {
    public:
        virtual ~InputNeuron() { }

        virtual void update(double dt = 1.0) { }
        virtual void commit() { }
        
        virtual void setParams(const std::string &param, double value);
        
        virtual void setInputValue(double value) = 0;
    };
    
    class CurrentInputNeuron : public InputNeuron
    {
    public:
        virtual ~CurrentInputNeuron() { }
        
        virtual void setInputValue(double value) { lastCurrent = value; }
    };
    
    class SimpleSpikeInputNeuron : public InputNeuron
    {
    public:
        virtual ~SimpleSpikeInputNeuron() { }
        
        virtual void setInputValue(double value) { lastSpike = value != 0.0; }
        
        void setSpike(bool spike) { lastSpike = spike; }
    };
    
    class FiringRateInputNeuron : public InputNeuron
    {
    public:
        virtual ~FiringRateInputNeuron() { }
        
        virtual void setInputValue(double value) { probability = value; }
        virtual void commit() { lastSpike = An::boolRand(probability); }
    
    protected:
        double probability; 
    };
    
    class FiringRateOutputNeuron : public Neuron
    {
    public:
        FiringRateOutputNeuron() : totalSpike(0), queueSize(20) { }
        virtual ~FiringRateOutputNeuron() { }
        
        virtual void setParams(const std::string &param, double value);
        virtual void update(double dt = 1.0);
        virtual void commit();
        
    protected:
        std::queue<unsigned> spikes; 
        unsigned totalSpike; 
        unsigned queueSize; 
        
        // FIXME: this is hacky, since it is dependend on step-size. It is
        // working for the dt = 1.0 case but doesnt scale well to different
        // time-step size values.
    };
    
    class Synapse
    {
    public:
        double weight; 
        TagSet tags; 
    
    public:
        Synapse();
        virtual ~Synapse();
        
        virtual void init(Neuron* pre, Neuron* post, const double weight = 0);
        virtual void finalize() { }
    
        virtual void setParams(const std::map<std::string, double> params);
        virtual void setParams(const std::string &param, double value);
        
        virtual bool getSpike() const {return preNeuron ? preNeuron->getSpike() : false;}
        virtual double getCurrent() const {return preNeuron ? preNeuron->getCurrent() : 0.0;}
        
        virtual void update(double dt = 1.0) {}
        
        const Neuron *getPreNeuron() const { return preNeuron; }
        
        const Neuron *getPostNeuron() const { return postNeuron; }
    
    protected:
        Neuron* preNeuron; 
        Neuron* postNeuron; 
    };
}


#endif

---