STDPFunctions.cpp

Go to the documentation of this file.

//SpikeStream includes
#include "SpikeStreamException.h"
#include "StandardSTDPFunction.h"
#include "StepSTDPFunction.h"
#include "STDPFunctions.h"
using namespace spikestream;

//Declare static variables
unsigned STDPFunctions::STANDARD_STDP = 0;
unsigned STDPFunctions::STEP_STDP = 1;
bool STDPFunctions::initialized = false;
QHash<unsigned, AbstractSTDPFunction*> STDPFunctions::functionMap;


/*----------------------------------------------------------*/
/*-----                 PUBLIC METHODS                 -----*/
/*----------------------------------------------------------*/

void STDPFunctions::cleanup(){
        for(QHash<unsigned, AbstractSTDPFunction*>::iterator iter = functionMap.begin(); iter != functionMap.end(); ++iter)
                delete iter.value();
        functionMap.clear();
        initialized = false;
}


timestep_t STDPFunctions::getApplySTDPInterval(unsigned functionID){
        checkFunctionID(functionID);
        return functionMap[functionID]->getApplySTDPInterval();
}


QHash<QString, double> STDPFunctions::getParameters(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getParameters();
}


void STDPFunctions::setParameters(unsigned functionID, QHash<QString, double>& newParameterMap){
        checkInitialization();
        checkFunctionID(functionID);
        functionMap[functionID]->setParameters(newParameterMap);
}


QHash<QString, double> STDPFunctions::getDefaultParameters(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getDefaultParameters();
}


QList<ParameterInfo> STDPFunctions::getParameterInfoList(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getParameterInfoList();
}


QString STDPFunctions::getFunctionDescription(unsigned functionID){
        if(functionID == STANDARD_STDP)
                return "Standard STDP function.";
        else if(functionID == STEP_STDP)
                return "Step STDP function.";
        throw SpikeStreamException("STDP Function ID not recognized: " + QString::number(functionID));
}


QList<unsigned> STDPFunctions::getFunctionIDs(){
        QList<unsigned> tmpList;
        tmpList.append(STANDARD_STDP);
        tmpList.append(STEP_STDP);
        return tmpList;
}


float* STDPFunctions::getPreArray(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getPreArray();
}


int STDPFunctions::getPreLength(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getPreLength();
}


float* STDPFunctions::getPostArray(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getPostArray();
}


int STDPFunctions::getPostLength(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getPostLength();
}


float STDPFunctions::getMinExcitatoryWeight(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getMinExcitatoryWeight();
}


float STDPFunctions::getMaxExcitatoryWeight(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getMaxExcitatoryWeight();
}


float STDPFunctions::getMinInhibitoryWeight(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getMinInhibitoryWeight();
}


float STDPFunctions::getMaxInhibitoryWeight(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getMaxInhibitoryWeight();
}


float STDPFunctions::getReward(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        return functionMap[functionID]->getReward();
}


void STDPFunctions::print(unsigned functionID){
        checkInitialization();
        checkFunctionID(functionID);
        functionMap[functionID]->print();
}

/*----------------------------------------------------------*/
/*-----                PRIVATE METHODS                 -----*/
/*----------------------------------------------------------*/

void STDPFunctions::checkFunctionID(unsigned functionID){
        if(!functionMap.contains(functionID))
                throw SpikeStreamException("Function ID not recognized: " + QString::number(functionID));
}


void STDPFunctions::checkInitialization(){
        if(initialized)
                return;
        initialize();
}


void STDPFunctions::initialize(){
        //Create a class for each STDP function
        functionMap[STANDARD_STDP] = new StandardSTDPFunction();
        functionMap[STEP_STDP] = new StepSTDPFunction();

        //Record the fact that initialization has now been carried out.
        initialized = true;
}