connector.hpp

Go to the documentation of this file.

/*
 *  Cypress -- C++ Spiking Neural Network Simulation Framework
 *  Copyright (C) 2016  Andreas Stöckel
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef CYPRESS_CORE_CONNECTOR_HPP
#define CYPRESS_CORE_CONNECTOR_HPP

#include <algorithm>
#include <memory>
#include <random>
#include <string>
#include <vector>

#include <cypress/core/synapses.hpp>
#include <cypress/core/types.hpp>
#include <cypress/util/comperator.hpp>

namespace cypress {
struct Synapse {
    Real weight;

    Real delay;

    explicit Synapse(Real weight = 0.0, Real delay = 0.0)
        : weight(weight), delay(delay)
    {
    }

    bool excitatory() const { return weight > 0.0; }

    bool inhibitory() const { return weight < 0.0; }

    bool valid() const { return (weight != 0.0) && (delay >= 0.0); }
};

struct LocalConnection {
    NeuronIndex src;

    NeuronIndex tar;

    std::vector<Real> SynapseParameters;

    LocalConnection(uint32_t src = 0, uint32_t tar = 0, Real weight = 0.0,
                    Real delay = 0.0)
        : src(src), tar(tar), SynapseParameters({weight, delay})
    {
    }
    LocalConnection(uint32_t src, uint32_t tar, SynapseBase &synapse)
        : src(src), tar(tar), SynapseParameters(synapse.parameters())
    {
    }

    bool valid() const
    {
        return (SynapseParameters[0] != 0.0) && (SynapseParameters[1] >= 0.0);
    }

    bool excitatory() const { return SynapseParameters[0] > 0; }

    bool inhibitory() const { return SynapseParameters[0] < 0; }

    LocalConnection absolute_connection()
    {
        LocalConnection temp = *this;
        temp.SynapseParameters[0] = std::abs(SynapseParameters[0]);
        return temp;
    }

    bool operator==(const LocalConnection &s) const
    {
        return Comperator<uint32_t>::equals(
                   1 - uint32_t(valid()), 1 - uint32_t(s.valid()))(src, s.src)(
                   tar, s.tar)() &&
               SynapseParameters == s.SynapseParameters;
    }

    bool operator<(const LocalConnection &s) const
    {
        return Comperator<uint32_t>::smaller(
            1 - uint32_t(valid()), 1 - uint32_t(s.valid()))(src, s.src)(
            tar, s.tar)();
    }
};

/*
 * Forward declarations.
 */
class ConnectionDescriptor;
class AllToAllConnector;
class OneToOneConnector;
class FromListConnector;

template <typename Callback>
class FunctorConnector;

template <typename Callback>
class UniformFunctorConnector;

template <typename RandomEngine>
class FixedProbabilityConnector;

template <typename RandomEngine>
class RandomConnector;

template <typename RandomEngine>
class FixedFanInConnector;

template <typename RandomEngine>
class FixedFanOutConnector;

class Connector {
protected:
    std::shared_ptr<SynapseBase> m_synapse;

    std::vector<LocalConnection> m_weights;

    Real m_additional_parameter = 0.0;

    bool m_self_connections = true;

    bool m_seed_given = false;

    explicit Connector(SynapseBase &synapse, bool self_connections)
    {
        m_synapse = SynapseBase::make_shared(synapse);
        m_self_connections = self_connections;
    }
    explicit Connector(std::shared_ptr<SynapseBase> synapse,
                       bool self_connections)
    {
        m_synapse = std::move(synapse);
        m_self_connections = self_connections;
    }
    Connector(Real weight, Real delay, bool self_connections)
    {
        m_synapse =
            std::make_shared<StaticSynapse>(StaticSynapse({weight, delay}));
        m_self_connections = self_connections;
    }

public:
    virtual ~Connector() = default;

    virtual void connect(const ConnectionDescriptor &descr,
                         std::vector<LocalConnection> &tar) const = 0;

    virtual bool valid(const ConnectionDescriptor &descr) const = 0;

    bool allow_self_connections() const { return m_self_connections; }

    Real additional_parameter() const { return m_additional_parameter; }

    virtual std::string name() const = 0;

    virtual size_t size(size_t size_src_pop, size_t size_target_pop) const = 0;

    const std::shared_ptr<SynapseBase> synapse() const { return m_synapse; }

    const std::string synapse_name() const { return m_synapse->name(); }

    const std::vector<LocalConnection> &learned_weights() const
    {
        if (!m_synapse->learning()) {
            throw CypressException(
                "Requested learned weights, although Synapse is static");
        }
        return m_weights;
    }

    void _store_learned_weights(std::vector<LocalConnection> &&weights)
    {
        m_weights = std::move(weights);
    }

    static std::unique_ptr<AllToAllConnector> all_to_all(
        Real weight = 1.0, Real delay = 0.0,
        bool allow_self_connections = true);
    static std::unique_ptr<AllToAllConnector> all_to_all(
        SynapseBase &synapse, bool allow_self_connections = true);

    static std::unique_ptr<OneToOneConnector> one_to_one(Real weight = 1.0,
                                                         Real delay = 0.0);

    static std::unique_ptr<OneToOneConnector> one_to_one(SynapseBase &synapse);

    static std::unique_ptr<FromListConnector> from_list(
        const std::vector<LocalConnection> &connections);

    static std::unique_ptr<FromListConnector> from_list(
        std::initializer_list<LocalConnection> connections);

    static std::unique_ptr<FromListConnector> from_list(
        const std::vector<LocalConnection> &connections, SynapseBase &synapse);

    static std::unique_ptr<FromListConnector> from_list(
        std::initializer_list<LocalConnection> connections,
        SynapseBase &synapse);

    template <typename F>
    static std::unique_ptr<FunctorConnector<F>> functor(const F &cback);

    template <typename F>
    static std::unique_ptr<UniformFunctorConnector<F>> functor(
        const F &cback, Real weight, Real delay = 0.0);

    static std::unique_ptr<
        FixedProbabilityConnector<std::default_random_engine>>
    fixed_probability(std::unique_ptr<Connector> connector, Real p,
                      bool allow_self_connections = true);

    static std::unique_ptr<
        FixedProbabilityConnector<std::default_random_engine>>
    fixed_probability(std::unique_ptr<Connector> connector, Real p, size_t seed,
                      bool allow_self_connections = true);

    static std::unique_ptr<RandomConnector<std::default_random_engine>> random(
        Real weight = 1, Real delay = 0, Real probability = 1,
        bool allow_self_connections = true);

    static std::unique_ptr<RandomConnector<std::default_random_engine>> random(
        SynapseBase &synapse, Real probability = 1,
        bool allow_self_connections = true);

    static std::unique_ptr<RandomConnector<std::default_random_engine>> random(
        Real weight, Real delay, Real probability, size_t seed,
        bool allow_self_connections = true);

    static std::unique_ptr<RandomConnector<std::default_random_engine>> random(
        SynapseBase &synapse, Real probability, size_t seed,
        bool allow_self_connections = true);

    static std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
    fixed_fan_in(size_t n_fan_in, Real weight, Real delay = 0.0,
                 bool allow_self_connections = true);

    static std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
    fixed_fan_in(size_t n_fan_in, SynapseBase &synapse,
                 bool allow_self_connections = true);

    static std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
    fixed_fan_in(size_t n_fan_in, Real weight, Real delay, size_t seed,
                 bool allow_self_connections = true);

    static std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
    fixed_fan_in(size_t n_fan_in, SynapseBase &synapse, size_t seed,
                 bool allow_self_connections = true);

    static std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
    fixed_fan_out(size_t n_fan_out, Real weight, Real delay = 0.0,
                  bool allow_self_connections = true);

    static std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
    fixed_fan_out(size_t n_fan_out, SynapseBase &synapse,
                  bool allow_self_connections = true);

    static std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
    fixed_fan_out(size_t n_fan_out, Real weight, Real delay, size_t seed,
                  bool allow_self_connections = true);

    static std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
    fixed_fan_out(size_t n_fan_out, SynapseBase &synapse, size_t seed,
                  bool allow_self_connections = true);
};

class ConnectionDescriptor {
private:
    PopulationIndex m_pid_src;
    NeuronIndex m_nid_src0;
    NeuronIndex m_nid_src1;
    PopulationIndex m_pid_tar;
    NeuronIndex m_nid_tar0;
    NeuronIndex m_nid_tar1;
    std::shared_ptr<Connector> m_connector;
    std::string m_label;

public:
    ConnectionDescriptor(uint32_t pid_src, uint32_t nid_src0, uint32_t nid_src1,
                         uint32_t pid_tar, uint32_t nid_tar0, uint32_t nid_tar1,
                         std::shared_ptr<Connector> connector = nullptr,
                         const char *label = "")
        : m_pid_src(pid_src),
          m_nid_src0(nid_src0),
          m_nid_src1(nid_src1),
          m_pid_tar(pid_tar),
          m_nid_tar0(nid_tar0),
          m_nid_tar1(nid_tar1),
          m_connector(std::move(connector)),
          m_label(std::string(label))
    {
    }

    PopulationIndex pid_src() const { return m_pid_src; }

    NeuronIndex nid_src0() const { return m_nid_src0; }

    NeuronIndex nid_src1() const { return m_nid_src1; }

    PopulationIndex pid_tar() const { return m_pid_tar; }

    NeuronIndex nid_tar0() const { return m_nid_tar0; }

    NeuronIndex nid_tar1() const { return m_nid_tar1; }

    Connector &connector() const { return *m_connector; }

    void update_connector(std::shared_ptr<Connector> connector)
    {
        m_connector = std::move(connector);
    }

    void connect(std::vector<LocalConnection> &tar) const
    {
        connector().connect(*this, tar);
    }

    bool valid() const { return m_connector && connector().valid(*this); }

    NeuronIndex nsrc() const { return m_nid_src1 - m_nid_src0; }

    NeuronIndex ntar() const { return m_nid_tar1 - m_nid_tar0; }

    bool operator==(const ConnectionDescriptor &s) const
    {
        return Comperator<uint32_t>::equals(m_pid_src, s.m_pid_src)(
            m_pid_tar, s.m_pid_tar)(m_nid_src0, s.m_nid_src0)(
            m_nid_src1, s.m_nid_src1)(m_nid_tar0, s.m_nid_tar0)(m_nid_tar1,
                                                                s.m_nid_tar1)();
    }

    bool operator<(const ConnectionDescriptor &s) const
    {
        return Comperator<uint32_t>::smaller(m_pid_src, s.m_pid_src)(
            m_pid_tar, s.m_pid_tar)(m_nid_src0, s.m_nid_src0)(
            m_nid_src1, s.m_nid_src1)(m_nid_tar0, s.m_nid_tar0)(m_nid_tar1,
                                                                s.m_nid_tar1)();
    }

    size_t size()
    {
        return connector().size(m_nid_src1 - m_nid_src0,
                                m_nid_tar1 - m_nid_tar0);
    }

    const std::string &label() const { return m_label; }
};

std::vector<std::vector<LocalConnection>> instantiate_connections(
    const std::vector<ConnectionDescriptor> &descrs);

bool instantiate_connections_to_file(
    std::string filename, const std::vector<ConnectionDescriptor> &descrs);

class UniformConnector : public Connector {
public:
    explicit UniformConnector(Real weight = 0.0, Real delay = 0.0,
                              bool self_connections = true)
        : Connector(weight, delay, self_connections)
    {
    }
    explicit UniformConnector(SynapseBase &synapse,
                              bool self_connections = true)
        : Connector(synapse, self_connections)
    {
    }
};

class AllToAllConnector : public UniformConnector {
public:
    using UniformConnector::UniformConnector;

    ~AllToAllConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override;

    bool valid(const ConnectionDescriptor &) const override { return true; }

    size_t size(size_t size_src_pop, size_t size_target_pop) const override
    {
        return size_src_pop * size_target_pop;
    }

    std::string name() const override { return "AllToAllConnector"; }
};

class OneToOneConnector : public UniformConnector {
public:
    using UniformConnector::UniformConnector;

    ~OneToOneConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override;

    bool valid(const ConnectionDescriptor &descr) const override
    {
        return descr.nsrc() == descr.ntar();
    }

    size_t size(size_t size_src_pop, size_t) const override
    {
        return size_src_pop;
    }

    std::string name() const override { return "OneToOneConnector"; }
};

class FromListConnector : public Connector {
private:
    std::vector<LocalConnection> m_connections;
    void check_synapse()
    {
        if (m_connections.size() > 0 &&
            m_synapse->parameter_names().size() !=
                m_connections[0].SynapseParameters.size()) {
            throw CypressException(
                "Please provide an instance of the synapse type in the from "
                "list connector!");
        }
    }

public:
    explicit FromListConnector(std::vector<LocalConnection> connections,
                               SynapseBase &synapse)
        : Connector(synapse, true), m_connections(std::move(connections))
    {
        check_synapse();
    }

    FromListConnector(std::initializer_list<LocalConnection> connections,
                      SynapseBase &synapse)
        : Connector(synapse, true), m_connections(connections)
    {
        check_synapse();
    }

    explicit FromListConnector(std::vector<LocalConnection> connections)
        : Connector(0.0, 0.0, true), m_connections(std::move(connections))
    {
        check_synapse();
    }

    FromListConnector(std::initializer_list<LocalConnection> connections)
        : Connector(0.0, 0.0, true), m_connections(connections)
    {
        check_synapse();
    }

    ~FromListConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override;

    bool valid(const ConnectionDescriptor &) const override { return true; }

    size_t size(size_t, size_t) const override { return m_connections.size(); }

    std::string name() const override { return "FromListConnector"; }

    void update_learned_weights();

    std::vector<LocalConnection> &get_connections() { return m_connections; }
};

class FunctorConnectorBase : public Connector {
protected:
    FunctorConnectorBase() : Connector(0, 0, true) {}

public:
    std::string name() const override { return "FunctorConnector"; }
};

template <typename Callback>
class FunctorConnector : public FunctorConnectorBase {
private:
    Callback m_cback;

public:
    explicit FunctorConnector(const Callback &cback) : m_cback(cback) {}

    ~FunctorConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override
    {
        for (NeuronIndex n_src = descr.nid_src0(); n_src < descr.nid_src1();
             n_src++) {
            for (NeuronIndex n_tar = descr.nid_tar0(); n_tar < descr.nid_tar1();
                 n_tar++) {
                Synapse synapse = m_cback(n_src, n_tar);
                if (synapse.valid()) {
                    tar.emplace_back(n_src, n_tar, synapse.weight,
                                     synapse.delay);
                }
            }
        }
    }

    bool valid(const ConnectionDescriptor &) const override { return true; }

    size_t size(size_t size_src_pop, size_t size_target_pop) const override
    {
        return size_src_pop * size_target_pop;
    }
};

class UniformFunctorConnectorBase : public UniformConnector {
public:
    using UniformConnector::UniformConnector;

    std::string name() const override { return "UniformFunctorConnector"; }

    size_t size(size_t size_src_pop, size_t size_target_pop) const override
    {
        return size_src_pop * size_target_pop;
    }
};

template <typename Callback>
class UniformFunctorConnector : public UniformFunctorConnectorBase {
private:
    Callback m_cback;

public:
    explicit UniformFunctorConnector(const Callback &cback, Real weight = 0.0,
                                     Real delay = 0.0)
        : UniformFunctorConnectorBase(weight, delay, true), m_cback(cback)
    {
    }
    UniformFunctorConnector(const Callback &cback, SynapseBase &synapse)
        : UniformFunctorConnectorBase(synapse, true), m_cback(cback)
    {
    }

    ~UniformFunctorConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override
    {
        for (NeuronIndex n_src = descr.nid_src0(); n_src < descr.nid_src1();
             n_src++) {
            for (NeuronIndex n_tar = descr.nid_tar0(); n_tar < descr.nid_tar1();
                 n_tar++) {
                if (m_cback(n_src, n_tar)) {
                    tar.emplace_back(n_src, n_tar, *m_synapse);
                }
            }
        }
    }

    bool valid(const ConnectionDescriptor &) const override { return true; }
};

class FixedProbabilityConnectorBase : public Connector {
protected:
    std::string name_string = "FixedProbabilityConnector";
    FixedProbabilityConnectorBase(std::shared_ptr<SynapseBase> synapse,
                                  bool self_connections)
        : Connector(std::move(synapse), self_connections)
    {
    }

public:
    std::string name() const override { return name_string; }

    void seed_given() { m_seed_given = true; }
};

template <typename RandomEngine>
class FixedProbabilityConnector : public FixedProbabilityConnectorBase {
protected:
    std::unique_ptr<Connector> m_connector;
    std::shared_ptr<RandomEngine> m_engine;

public:
    FixedProbabilityConnector(std::unique_ptr<Connector> connector, Real p,
                              std::shared_ptr<RandomEngine> engine,
                              bool self_connections)
        : FixedProbabilityConnectorBase(connector->synapse(), self_connections),
          m_connector(std::move(connector)),
          m_engine(std::move(engine))
    {
        m_additional_parameter = p;
    }

    ~FixedProbabilityConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override
    {
        const size_t first = tar.size();   // Old number of connections
        m_connector->connect(descr, tar);  // Instantiate the connections
        std::uniform_real_distribution<Real> distr(0.0, 1.0);
        for (size_t i = first; i < tar.size(); i++) {
            if (distr(*m_engine) >= m_additional_parameter) {
                tar[i].SynapseParameters[0] = 0.0;  // Invalidate the connection
            }
        }

        if ((!descr.connector().allow_self_connections()) &&
            descr.pid_src() == descr.pid_tar()) {
            for (size_t i = first; i < tar.size(); i++) {
                if (tar[i].src == tar[i].tar) {
                    tar[i].SynapseParameters[0] =
                        0.0;  // Invalidate the connection
                }
            }
        }
    }

    bool valid(const ConnectionDescriptor &descr) const override
    {
        return m_connector->valid(descr);
    }

    size_t size(size_t size_src_pop, size_t size_target_pop) const override
    {
        return size_t(Real(size_src_pop * size_target_pop) *
                      m_additional_parameter);
    }
};

template <typename RandomEngine>
class RandomConnector : public FixedProbabilityConnector<RandomEngine> {
private:
    using Base = FixedProbabilityConnector<RandomEngine>;

public:
    RandomConnector(Real weight, Real delay, Real probability,
                    std::shared_ptr<RandomEngine> engine, bool self_connections)
        : FixedProbabilityConnector<RandomEngine>(
              Connector::all_to_all(weight, delay), probability, engine,
              self_connections)
    {
        FixedProbabilityConnectorBase::name_string = "RandomConnector";
    }
    RandomConnector(SynapseBase &synapse, Real probability,
                    std::shared_ptr<RandomEngine> engine, bool self_connections)
        : FixedProbabilityConnector<RandomEngine>(
              Connector::all_to_all(synapse), probability, engine,
              self_connections)
    {
        FixedProbabilityConnectorBase::name_string = "RandomConnector";
    }

    std::string name() const override { return "RandomConnector"; }
};

template <typename RandomEngine>
class FixedFanConnectorBase : public UniformConnector {
private:
    std::shared_ptr<RandomEngine> m_engine;

protected:
    template <typename F>
    void generate_connections(size_t offs, size_t len, size_t subset_len,
                              size_t i0, size_t i1, const F &f, bool self) const
    {
        // Initialize a vector with the identity permutation
        std::vector<size_t> perm(len);
        for (size_t i = 0; i < len; i++) {
            perm[i] = offs + i;
        }

        // Iterate over each target neuron, create a new permutation containing
        // the source neuron indices and instantiate the connection
        std::uniform_int_distribution<size_t> distr(0, perm.size() - 1);
        for (size_t i = i0; i < i1; i++) {
            // Generate a new permutation for the first subset_len elements
            for (size_t j = 0; j < subset_len; j++) {
                std::swap(perm[j], perm[distr(*m_engine)]);
            }
            // Create the connections
            if (self) {
                for (size_t j = 0; j < subset_len; j++) {
                    f(i, perm[j]);
                }
            }
            else {
                size_t sub_len = subset_len;
                for (size_t j = 0; j < sub_len; j++) {
                    if (i != perm[j]) {
                        f(i, perm[j]);
                    }
                    else {
                        sub_len = std::min(sub_len + 1, perm.size());
                    }
                }
            }
        }
    }

public:
    FixedFanConnectorBase(Real weight, Real delay,
                          std::shared_ptr<RandomEngine> engine,
                          bool self_connections)
        : UniformConnector(weight, delay, self_connections),
          m_engine(std::move(engine))
    {
    }
    FixedFanConnectorBase(SynapseBase &synapse,
                          std::shared_ptr<RandomEngine> engine,
                          bool self_connections)
        : UniformConnector(synapse, self_connections),
          m_engine(std::move(engine))
    {
    }

    void seed_given() { m_seed_given = true; }
};

template <typename RandomEngine>
class FixedFanInConnector : public FixedFanConnectorBase<RandomEngine> {
private:
    using Base = FixedFanConnectorBase<RandomEngine>;

public:
    FixedFanInConnector(size_t n_fan_in, Real weight, Real delay,
                        std::shared_ptr<RandomEngine> engine,
                        bool self_connections)
        : FixedFanConnectorBase<RandomEngine>(weight, delay, std::move(engine),
                                              self_connections)
    {
        Base::m_additional_parameter = n_fan_in;
    }
    FixedFanInConnector(size_t n_fan_in, SynapseBase &synapse,
                        std::shared_ptr<RandomEngine> engine,
                        bool self_connections)
        : FixedFanConnectorBase<RandomEngine>(synapse, std::move(engine),
                                              self_connections)
    {
        Base::m_additional_parameter = n_fan_in;
    }

    ~FixedFanInConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override
    {
        if (descr.pid_src() == descr.pid_tar()) {
            Base::generate_connections(
                descr.nid_src0(), descr.nsrc(), Base::m_additional_parameter,
                descr.nid_tar0(), descr.nid_tar1(),
                [&](size_t i, size_t r) {
                    tar.emplace_back(r, i, *this->m_synapse);
                },
                descr.connector().allow_self_connections());
        }
        else {
            Base::generate_connections(
                descr.nid_src0(), descr.nsrc(), Base::m_additional_parameter,
                descr.nid_tar0(), descr.nid_tar1(),
                [&](size_t i, size_t r) {
                    tar.emplace_back(r, i, *this->m_synapse);
                },
                true);
        }
    }

    bool valid(const ConnectionDescriptor &descr) const override
    {
        return descr.nsrc() >= NeuronIndex(Base::m_additional_parameter);
    }

    std::string name() const override { return "FixedFanInConnector"; }

    size_t size(size_t, size_t size_target_pop) const override
    {
        return Base::m_additional_parameter * size_target_pop;
    }
};

template <typename RandomEngine>
class FixedFanOutConnector : public FixedFanConnectorBase<RandomEngine> {
private:
    using Base = FixedFanConnectorBase<RandomEngine>;

public:
    FixedFanOutConnector(size_t n_fan_out, Real weight, Real delay,
                         std::shared_ptr<RandomEngine> engine,
                         bool self_connections)
        : Base(weight, delay, std::move(engine), self_connections)
    {
        Base::m_additional_parameter = n_fan_out;
    }

    FixedFanOutConnector(size_t n_fan_out, SynapseBase &synapse,
                         std::shared_ptr<RandomEngine> engine,
                         bool self_connections)
        : Base(synapse, std::move(engine), self_connections)
    {
        Base::m_additional_parameter = n_fan_out;
    }

    ~FixedFanOutConnector() override = default;

    void connect(const ConnectionDescriptor &descr,
                 std::vector<LocalConnection> &tar) const override
    {
        if (descr.pid_src() == descr.pid_tar()) {
            Base::generate_connections(
                descr.nid_tar0(), descr.ntar(), Base::m_additional_parameter,
                descr.nid_src0(), descr.nid_src1(),
                [&](size_t i, size_t r) {
                    tar.emplace_back(i, r, *this->m_synapse);
                },
                descr.connector().allow_self_connections());
        }
        else {
            Base::generate_connections(
                descr.nid_tar0(), descr.ntar(), Base::m_additional_parameter,
                descr.nid_src0(), descr.nid_src1(),
                [&](size_t i, size_t r) {
                    tar.emplace_back(i, r, *this->m_synapse);
                },
                true);
        }
    }

    bool valid(const ConnectionDescriptor &descr) const override
    {
        return descr.ntar() >= NeuronIndex(Base::m_additional_parameter);
    }

    std::string name() const override { return "FixedFanOutConnector"; }

    size_t size(size_t size_src_pop, size_t) const override
    {
        return size_src_pop * Base::m_additional_parameter;
    }
};

inline std::unique_ptr<AllToAllConnector> Connector::all_to_all(
    Real weight, Real delay, bool self_connections)
{
    return std::make_unique<AllToAllConnector>(weight, delay, self_connections);
}
inline std::unique_ptr<AllToAllConnector> Connector::all_to_all(
    SynapseBase &synapse, bool self_connections)
{
    return std::make_unique<AllToAllConnector>(synapse, self_connections);
}

inline std::unique_ptr<OneToOneConnector> Connector::one_to_one(Real weight,
                                                                Real delay)
{
    return std::make_unique<OneToOneConnector>(weight, delay);
}
inline std::unique_ptr<OneToOneConnector> Connector::one_to_one(
    SynapseBase &synapse)
{
    return std::make_unique<OneToOneConnector>(synapse);
}

inline std::unique_ptr<FromListConnector> Connector::from_list(
    const std::vector<LocalConnection> &connections, SynapseBase &synapse)
{
    return std::make_unique<FromListConnector>(connections, synapse);
}

inline std::unique_ptr<FromListConnector> Connector::from_list(
    std::initializer_list<LocalConnection> connections, SynapseBase &synapse)
{
    return std::make_unique<FromListConnector>(connections, synapse);
}

inline std::unique_ptr<FromListConnector> Connector::from_list(
    const std::vector<LocalConnection> &connections)
{
    return std::make_unique<FromListConnector>(connections);
}

inline std::unique_ptr<FromListConnector> Connector::from_list(
    std::initializer_list<LocalConnection> connections)
{
    return std::make_unique<FromListConnector>(connections);
}

template <typename F>
inline std::unique_ptr<FunctorConnector<F>> Connector::functor(const F &cback)
{
    return std::make_unique<FunctorConnector<F>>(cback);
}

template <typename F>
inline std::unique_ptr<UniformFunctorConnector<F>> Connector::functor(
    const F &cback, Real weight, Real delay)
{
    return std::make_unique<UniformFunctorConnector<F>>(cback, weight, delay);
}
/*template <typename F>
inline std::unique_ptr<UniformFunctorConnector<F>> Connector::functor(
    const F &cback, SynapseBase& synapse)
{
    return std::make_unique<UniformFunctorConnector<F>>(cback, synapse);
}*/

inline std::unique_ptr<FixedProbabilityConnector<std::default_random_engine>>
Connector::fixed_probability(std::unique_ptr<Connector> connector, Real p,
                             bool self_connections)
{
    return fixed_probability(std::move(connector), p, std::random_device()(),
                             self_connections);
}

inline std::unique_ptr<FixedProbabilityConnector<std::default_random_engine>>
Connector::fixed_probability(std::unique_ptr<Connector> connector, Real p,
                             size_t seed, bool self_connections)
{
    auto tmp =
        std::make_unique<FixedProbabilityConnector<std::default_random_engine>>(
            std::move(connector), p,
            std::make_shared<std::default_random_engine>(seed),
            self_connections);
    tmp->seed_given();
    return tmp;
}

inline std::unique_ptr<RandomConnector<std::default_random_engine>>
Connector::random(Real weight, Real delay, Real probability,
                  bool self_connections)
{
    return std::make_unique<RandomConnector<std::default_random_engine>>(
        weight, delay, probability,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}

inline std::unique_ptr<RandomConnector<std::default_random_engine>>
Connector::random(SynapseBase &synapse, Real probability, bool self_connections)
{
    return std::make_unique<RandomConnector<std::default_random_engine>>(
        synapse, probability,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}

inline std::unique_ptr<RandomConnector<std::default_random_engine>>
Connector::random(Real weight, Real delay, Real probability, size_t seed,
                  bool self_connections)
{
    auto tmp = std::make_unique<RandomConnector<std::default_random_engine>>(
        weight, delay, probability,
        std::make_shared<std::default_random_engine>(seed), self_connections);
    tmp->seed_given();
    return tmp;
}
inline std::unique_ptr<RandomConnector<std::default_random_engine>>
Connector::random(SynapseBase &synapse, Real probability, size_t seed,
                  bool self_connections)
{
    auto tmp = std::make_unique<RandomConnector<std::default_random_engine>>(
        synapse, probability,
        std::make_shared<std::default_random_engine>(seed), self_connections);
    tmp->seed_given();
    return tmp;
}

inline std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
Connector::fixed_fan_in(size_t n_fan_in, Real weight, Real delay,
                        bool self_connections)
{

    return std::make_unique<FixedFanInConnector<std::default_random_engine>>(
        n_fan_in, weight, delay,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}
inline std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
Connector::fixed_fan_in(size_t n_fan_in, SynapseBase &synapse,
                        bool self_connections)
{
    return std::make_unique<FixedFanInConnector<std::default_random_engine>>(
        n_fan_in, synapse,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}

inline std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
Connector::fixed_fan_in(size_t n_fan_in, Real weight, Real delay, size_t seed,
                        bool self_connections)
{
    auto tmp =
        std::make_unique<FixedFanInConnector<std::default_random_engine>>(
            n_fan_in, weight, delay,
            std::make_shared<std::default_random_engine>(seed),
            self_connections);
    tmp->seed_given();
    return tmp;
}
inline std::unique_ptr<FixedFanInConnector<std::default_random_engine>>
Connector::fixed_fan_in(size_t n_fan_in, SynapseBase &synapse, size_t seed,
                        bool self_connections)
{
    auto tmp =
        std::make_unique<FixedFanInConnector<std::default_random_engine>>(
            n_fan_in, synapse,
            std::make_shared<std::default_random_engine>(seed),
            self_connections);
    tmp->seed_given();
    return tmp;
}

inline std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
Connector::fixed_fan_out(size_t n_fan_out, Real weight, Real delay,
                         bool self_connections)
{
    return std::make_unique<FixedFanOutConnector<std::default_random_engine>>(
        n_fan_out, weight, delay,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}
inline std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
Connector::fixed_fan_out(size_t n_fan_out, SynapseBase &synapse,
                         bool self_connections)
{
    return std::make_unique<FixedFanOutConnector<std::default_random_engine>>(
        n_fan_out, synapse,
        std::make_shared<std::default_random_engine>(std::random_device()()),
        self_connections);
}

inline std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
Connector::fixed_fan_out(size_t n_fan_out, Real weight, Real delay, size_t seed,
                         bool self_connections)
{
    auto tmp =
        std::make_unique<FixedFanOutConnector<std::default_random_engine>>(
            n_fan_out, weight, delay,
            std::make_shared<std::default_random_engine>(seed),
            self_connections);
    tmp->seed_given();
    return tmp;
}
inline std::unique_ptr<FixedFanOutConnector<std::default_random_engine>>
Connector::fixed_fan_out(size_t n_fan_out, SynapseBase &synapse, size_t seed,
                         bool self_connections)
{
    auto tmp =
        std::make_unique<FixedFanOutConnector<std::default_random_engine>>(
            n_fan_out, synapse,
            std::make_shared<std::default_random_engine>(seed),
            self_connections);
    tmp->seed_given();
    return tmp;
}
}  // namespace cypress

#endif /* CYPRESS_CORE_CONNECTOR_HPP */