synapse_generators.h

Go to the documentation of this file.

 
#pragma once
 
#include <knp/core/population.h>
#include <knp/core/projection.h>
 
#include <exception>
#include <functional>
#include <optional>
#include <random>
#include <tuple>
 
#include "synapse_parameters_generators.h"
 
 
namespace knp::framework::projection
{
 
namespace synapse_generators
{
template <typename SynapseType>
[[nodiscard]] typename knp::core::Projection<SynapseType>::SynapseGenerator all_to_all(
    size_t presynaptic_pop_size, size_t postsynaptic_pop_size,
    parameters_generators::SynGen2ParamsType<SynapseType> syn_gen =
        parameters_generators::default_synapse_gen<SynapseType>)
{
    return [presynaptic_pop_size, postsynaptic_pop_size,
            syn_gen](size_t index) -> std::optional<typename knp::core::Projection<SynapseType>::Synapse>
    {
        const size_t index0 = index % presynaptic_pop_size;
        const size_t index1 = index / presynaptic_pop_size;
 
        return std::make_tuple(syn_gen(index0, index1), index0, index1);
    };
}
 
 
template <typename SynapseType>
[[nodiscard]] typename knp::core::Projection<SynapseType>::SynapseGenerator one_to_one(
    size_t population_size, parameters_generators::SynGen1ParamType<SynapseType> syn_gen = std::bind(
                                parameters_generators::default_synapse_gen<SynapseType>, std::placeholders::_1, 0))
{
    return [syn_gen](size_t index) -> std::optional<typename knp::core::Projection<SynapseType>::Synapse>
    { return std::make_tuple(syn_gen(index), index, index); };
}
 
 
template <typename SynapseType, template <typename...> class Container>
[[nodiscard]] typename knp::core::Projection<SynapseType>::SynapseGenerator from_container(
    const Container<typename core::Projection<SynapseType>::Synapse> &container)
{
    return [&container](size_t index) -> std::optional<typename knp::core::Projection<SynapseType>::Synapse>
    { return container[index]; };
}
 
 
template <typename SynapseType, template <typename, typename, typename...> class Map>
class FromMap
{
public:
    using MapType =
        Map<typename std::tuple<size_t, size_t>, typename knp::core::Projection<SynapseType>::SynapseParameters>;
 
    explicit FromMap(const MapType &synapses_map) : iter_(synapses_map.cbegin()) {}
 
    [[nodiscard]] typename std::optional<typename knp::core::Projection<SynapseType>::Synapse> operator()(size_t index)
    {
        const auto [from_index, to_index] = iter_->first;
        auto synapse = std::make_tuple(iter_->second, from_index, to_index);
        ++iter_;
        return synapse;
    }
 
private:
    typename MapType::const_iterator iter_;
};
 
 
template <typename SynapseType>
class FixedProbability
{
public:
    FixedProbability(
        size_t presynaptic_pop_size, size_t postsynaptic_pop_size, double connection_probability,
        parameters_generators::SynGen2ParamsType<SynapseType> syn_gen =
            parameters_generators::default_synapse_gen<SynapseType>)
        : presynaptic_pop_size_(presynaptic_pop_size),
          postsynaptic_pop_size_(postsynaptic_pop_size),
          connection_probability_(connection_probability),
          syn_gen_(syn_gen),
          mt_(std::random_device()()),
          dist_(0, 1)
    {
        if (connection_probability > 1 || connection_probability < 0)
            throw std::logic_error("Incorrect probability, set probability between 0 and 1.");
    }
 
    [[nodiscard]] typename std::optional<typename knp::core::Projection<SynapseType>::Synapse> operator()(size_t index)
    {
        const size_t index0 = index % presynaptic_pop_size_;
        const size_t index1 = index / presynaptic_pop_size_;
 
        if (dist_(mt_) < connection_probability_) return std::make_tuple(syn_gen_(index0, index1), index0, index1);
        return std::nullopt;
    }
 
private:
    size_t presynaptic_pop_size_;
    size_t postsynaptic_pop_size_;
    double connection_probability_;
    parameters_generators::SynGen2ParamsType<SynapseType> syn_gen_;
    std::mt19937 mt_;
    std::uniform_real_distribution<double> dist_;
};
 
 
template <typename SynapseType>
[[nodiscard]] typename knp::core::Projection<SynapseType>::SynapseGenerator index_based(
    size_t presynaptic_pop_size, size_t postsynaptic_pop_size,
    parameters_generators::SynGenOptional2ParamsType<SynapseType> syn_gen)
{
    return [presynaptic_pop_size, postsynaptic_pop_size,
            syn_gen](size_t index) -> std::optional<typename knp::core::Projection<SynapseType>::Synapse>
    {
        const size_t index0 = index % presynaptic_pop_size;
        const size_t index1 = index / presynaptic_pop_size;
        auto opt_result = syn_gen(index0, index1);
 
        if (opt_result.has_value()) return std::make_tuple(opt_result.value(), index0, index1);
        return std::nullopt;
    };
}
 
 
template <typename SynapseType>
class FixedNumberPost
{
public:
    FixedNumberPost(
        size_t presynaptic_pop_size, size_t postsynaptic_pop_size,
        std::function<typename knp::core::Projection<SynapseType>::SynapseParameters(size_t index0, size_t index1)>
            syn_gen = parameters_generators::default_synapse_gen<SynapseType>)
        : presynaptic_pop_size_(presynaptic_pop_size),
          postsynaptic_pop_size_(postsynaptic_pop_size),
          syn_gen_(syn_gen),
          mt_(std::random_device()()),
          dist_(0, postsynaptic_pop_size - 1)
    {
    }
 
    [[nodiscard]] typename std::optional<typename knp::core::Projection<SynapseType>::Synapse> operator()(size_t index)
    {
        const size_t index0 = index % presynaptic_pop_size_;
        const size_t index1 = dist_(mt_);
 
        return std::make_tuple(syn_gen_(index0, index1), index0, index1);
    }
 
private:
    size_t presynaptic_pop_size_;
    size_t postsynaptic_pop_size_;
    parameters_generators::SynGen2ParamsType<SynapseType> syn_gen_;
    std::mt19937 mt_;
    std::uniform_int_distribution<size_t> dist_;
};
 
 
template <typename SynapseType>
class FixedNumberPre
{
public:
    FixedNumberPre(
        size_t presynaptic_pop_size, size_t postsynaptic_pop_size,
        std::function<typename knp::core::Projection<SynapseType>::SynapseParameters(size_t index0, size_t index1)>
            syn_gen = parameters_generators::default_synapse_gen<SynapseType>)
        : presynaptic_pop_size_(presynaptic_pop_size),
          postsynaptic_pop_size_(postsynaptic_pop_size),
          syn_gen_(syn_gen),
          mt_(std::random_device()()),
          dist_(0, presynaptic_pop_size - 1)
    {
    }
 
    [[nodiscard]] typename std::optional<typename knp::core::Projection<SynapseType>::Synapse> operator()(size_t index)
    {
        const size_t index0 = dist_(mt_);
        const size_t index1 = index % postsynaptic_pop_size_;
 
        return std::make_tuple(syn_gen_(index0, index1), index0, index1);
    }
 
private:
    size_t presynaptic_pop_size_;
    size_t postsynaptic_pop_size_;
    parameters_generators::SynGen2ParamsType<SynapseType> syn_gen_;
    std::mt19937 mt_;
    std::uniform_int_distribution<size_t> dist_;
};
 
 
template <typename DestinationSynapseType, typename SourceSynapseType>
[[nodiscard]] typename knp::core::Projection<DestinationSynapseType>::SynapseGenerator clone_projection(
    const knp::core::Projection<SourceSynapseType> &source_proj,
    parameters_generators::SynGen1ParamType<DestinationSynapseType> syn_gen =
        parameters_generators::default_synapse_gen<DestinationSynapseType>)
{
    return [&source_proj,
            syn_gen](size_t index) -> std::optional<typename knp::core::Projection<DestinationSynapseType>::Synapse>
    {
        auto const &synapse = source_proj[index];
        return std::make_tuple(
            syn_gen(index), std::get<knp::core::source_neuron_id>(synapse),
            std::get<knp::core::target_neuron_id>(synapse));
    };
}
 
}  // namespace synapse_generators
 
}  // namespace knp::framework::projection