codeGenUtils.h

Go to the documentation of this file.

#pragma once

// Standard includes
#include <iomanip>
#include <limits>
#include <string>
#include <sstream>
#include <vector>

// GeNN includes
#include "variableMode.h"

using namespace std;

// Forward declarations
class NNmodel;
class SynapseGroup;

namespace NeuronModels
{
    class Base;
}

namespace NewModels
{
    class VarInit;
}

//--------------------------------------------------------------------------
// GenericFunction
//--------------------------------------------------------------------------
struct GenericFunction
{
    const std::string genericName;

    const unsigned int numArguments;
};

//--------------------------------------------------------------------------
// FunctionTemplate
//--------------------------------------------------------------------------

struct FunctionTemplate
{
    // **HACK** while GCC and CLang automatically generate this fine/don't require it, VS2013 seems to need it
    FunctionTemplate operator = (const FunctionTemplate &o)
    {
        return FunctionTemplate{o.genericName, o.numArguments, o.doublePrecisionTemplate, o.singlePrecisionTemplate};
    }

    const std::string genericName;

    const unsigned int numArguments;

    const std::string doublePrecisionTemplate;

    const std::string singlePrecisionTemplate;
};

//--------------------------------------------------------------------------
// PairKeyConstIter
//--------------------------------------------------------------------------
template<typename BaseIter>
class PairKeyConstIter : public BaseIter
{
private:
    //--------------------------------------------------------------------------
    // Typedefines
    //--------------------------------------------------------------------------
    typedef typename BaseIter::value_type::first_type KeyType;

public:
    PairKeyConstIter() {}
    PairKeyConstIter(BaseIter iter) : BaseIter(iter) {}

    //--------------------------------------------------------------------------
    // Operators
    //--------------------------------------------------------------------------
    const KeyType *operator -> () const
    {
        return (const KeyType *) &(BaseIter::operator -> ( )->first);
    }

    const KeyType &operator * () const
    {
        return BaseIter::operator * ( ).first;
    }
};

template<typename BaseIter>
inline PairKeyConstIter<BaseIter> GetPairKeyConstIter(BaseIter iter)
{
    return iter;
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
const std::vector<FunctionTemplate> cudaFunctions = {
    {"gennrand_uniform", 0, "curand_uniform_double($(rng))", "curand_uniform($(rng))"},
    {"gennrand_normal", 0, "curand_normal_double($(rng))", "curand_normal($(rng))"},
    {"gennrand_exponential", 0, "exponentialDistDouble($(rng))", "exponentialDistFloat($(rng))"},
    {"gennrand_log_normal", 2, "curand_log_normal_double($(rng), $(0), $(1))", "curand_log_normal_float($(rng), $(0), $(1))"},
    {"gennrand_gamma", 1, "gammaDistDouble($(rng), $(0))", "gammaDistFloat($(rng), $(0))"}
};

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
const std::vector<FunctionTemplate> cpuFunctions = {
    {"gennrand_uniform", 0, "standardUniformDistribution($(rng))", "standardUniformDistribution($(rng))"},
    {"gennrand_normal", 0, "standardNormalDistribution($(rng))", "standardNormalDistribution($(rng))"},
    {"gennrand_exponential", 0, "standardExponentialDistribution($(rng))", "standardExponentialDistribution($(rng))"},
    {"gennrand_log_normal", 2, "std::lognormal_distribution<double>($(0), $(1))($(rng))", "std::lognormal_distribution<float>($(0), $(1))($(rng))"},
    {"gennrand_gamma", 1, "std::gamma_distribution<double>($(0), 1.0)($(rng))", "std::gamma_distribution<float>($(0), 1.0f)($(rng))"}
};

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
void substitute(string &s, const string &trg, const string &rep);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
bool regexVarSubstitute(string &s, const string &trg, const string &rep);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
bool regexFuncSubstitute(string &s, const string &trg, const string &rep);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
bool isRNGRequired(const std::string &code);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
bool isInitRNGRequired(const std::vector<NewModels::VarInit> &varInitialisers, const std::vector<VarMode> &varModes,
                       VarInit initLocation);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
void functionSubstitute(std::string &code, const std::string &funcName,
                        unsigned int numParams, const std::string &replaceFuncTemplate);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
template<typename NameIter>
inline void name_substitutions(string &code, const string &prefix, NameIter namesBegin, NameIter namesEnd, const string &postfix= "", const string &ext = "")
{
    for (NameIter n = namesBegin; n != namesEnd; n++) {
        substitute(code,
                   "$(" + *n + ext + ")",
                   prefix + *n + postfix);
    }
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void name_substitutions(string &code, const string &prefix, const vector<string> &names, const string &postfix= "", const string &ext = "")
{
    name_substitutions(code, prefix, names.cbegin(), names.cend(), postfix, ext);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
template<class T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
void writePreciseString(std::ostream &os, T value)
{
    // Cache previous precision
    const std::streamsize previousPrecision = os.precision();

    // Set scientific formatting
    os << std::scientific;

    // Set precision to what is required to fully represent T
    os << std::setprecision(std::numeric_limits<T>::max_digits10);

    // Write value to stream
    os << value;

    // Reset to default formatting
    // **YUCK** GCC 4.8.X doesn't seem to include std::defaultfloat
    os.unsetf(std::ios_base::floatfield);
    //os << std::defaultfloat;

    // Restore previous precision
    os << std::setprecision(previousPrecision);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
template<class T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
std::string writePreciseString(T value)
{
    std::stringstream s;
    writePreciseString(s, value);
    return s.str();
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
template<typename NameIter>
inline void value_substitutions(string &code, NameIter namesBegin, NameIter namesEnd, const vector<double> &values, const string &ext = "")
{
    NameIter n = namesBegin;
    auto v = values.cbegin();
    for (;n != namesEnd && v != values.cend(); n++, v++) {
        stringstream stream;
        writePreciseString(stream, *v);
        substitute(code,
                   "$(" + *n + ext + ")",
                   "(" + stream.str() + ")");
    }
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void value_substitutions(string &code, const vector<string> &names, const vector<double> &values, const string &ext = "")
{
    value_substitutions(code, names.cbegin(), names.cend(), values, ext);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
void functionSubstitutions(std::string &code, const std::string &ftype,
                           const std::vector<FunctionTemplate> functions);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
string ensureFtype(const string &oldcode, const string &type);


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
void checkUnreplacedVariables(const string &code, const string &codeName);

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
uint32_t hashString(const std::string &string);


void preNeuronSubstitutionsInSynapticCode(
    string &wCode, 
    const SynapseGroup *sg,
    const string &offset,
    const string &axonalDelayOffset,
    const string &postIdx,
    const string &devPrefix,  
    const string &preVarPrefix = "",    
    const string &preVarSuffix = "");   

void postNeuronSubstitutionsInSynapticCode(
    string &wCode, 
    const SynapseGroup *sg,
    const string &offset,
    const string &backPropDelayOffset,
    const string &preIdx,
    const string &devPrefix, 
    const string &postVarPrefix = "",   
    const string &postVarSuffix = "");  

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
void neuron_substitutions_in_synaptic_code(
    string &wCode,                      
    const SynapseGroup *sg,             
    const string &preIdx,               
    const string &postIdx,              
    const string &devPrefix,            
    double dt,                          
    const string &preVarPrefix = "",    
    const string &preVarSuffix = "",    
    const string &postVarPrefix = "",   
    const string &postVarSuffix = "");