#include <connector.hpp>

Inheritance diagram for cypress::FixedFanInConnector< RandomEngine >:

Collaboration diagram for cypress::FixedFanInConnector< RandomEngine >:

[legend]

Public Member Functions
	FixedFanInConnector (size_t n_fan_in, Real weight, Real delay, std::shared_ptr< RandomEngine > engine, bool self_connections)

	FixedFanInConnector (size_t n_fan_in, SynapseBase &synapse, std::shared_ptr< RandomEngine > engine, bool self_connections)

	~FixedFanInConnector () override=default

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

bool	valid (const ConnectionDescriptor &descr) const override

std::string	name () const override

size_t	size (size_t, size_t size_target_pop) const override

void	seed_given ()

bool	allow_self_connections () const

Real	additional_parameter () const

const std::shared_ptr< SynapseBase >	synapse () const

const std::string	synapse_name () const

const std::vector< LocalConnection > &	learned_weights () const

void	_store_learned_weights (std::vector< LocalConnection > &&weights)

Static Public Member Functions
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)

Protected Member Functions
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

Protected Attributes
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

Detailed Description

template<typename RandomEngine>
class cypress::FixedFanInConnector< RandomEngine >

Connects each neuron in the target population with a fixed number of neurons in the source population.

Constructor & Destructor Documentation

template<typename RandomEngine >

cypress::FixedFanInConnector< RandomEngine >::FixedFanInConnector	(	size_t	n_fan_in,
		Real	weight,
		Real	delay,
		std::shared_ptr< RandomEngine >	engine,
		bool	self_connections
	)

inline

template<typename RandomEngine >

cypress::FixedFanInConnector< RandomEngine >::FixedFanInConnector	(	size_t	n_fan_in,
		SynapseBase &	synapse,
		std::shared_ptr< RandomEngine >	engine,
		bool	self_connections
	)

inline

template<typename RandomEngine >

cypress::FixedFanInConnector< RandomEngine >::~FixedFanInConnector ( )

overridedefault

Member Function Documentation

void cypress::Connector::_store_learned_weights ( std::vector< LocalConnection > && weights )

inlineinherited

Used internally to store the learned weights

Parameters

weights matrix of new weights

Real cypress::Connector::additional_parameter ( ) const

inlineinherited

std::unique_ptr< AllToAllConnector > cypress::Connector::all_to_all	(	Real	weight = `1.0`,
		Real	delay = `0.0`,
		bool	self_connections = `true`
	)

inlinestaticinherited

Creates an all-to-all connector and returns a pointer at the connector.

Parameters

weight	is the synaptic weight that should be used for all connections.
delay	is the synaptic delay that should be used for all connections.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

Inline methods

std::unique_ptr< AllToAllConnector > cypress::Connector::all_to_all	(	SynapseBase &	synapse,
		bool	allow_self_connections = `true`
	)

inlinestaticinherited

Creates an all-to-all connector and returns a pointer at the connector.

Parameters

synapse	Synapse object containing model and parameters
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

bool cypress::Connector::allow_self_connections ( ) const

inlineinherited

Flag which either allows (true) or forbids self connections if the source and target population are the same

template<typename RandomEngine >

void cypress::FixedFanInConnector< RandomEngine >::connect	(	const ConnectionDescriptor &	descr,
		std::vector< LocalConnection > &	tar
	)		const

inlineoverridevirtual

Tells the Connector to actually create the neuron-to-neuron connections between certain neurons.

Parameters

descr	is the connection descriptor containing the data detailing the connection.
tar	is the vector the connections should be appended to.

Implements cypress::Connector.

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

inlinestaticinherited

Connector which randomly selects neurons from the source population and ensures a fixed fan in (number of incomming connections) in each of the target neurons.

Parameters

n_fan_in	is the fan in that should be ensured.
weight	is the connection weight.
delay	is the synaptic delay.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the source population and ensures a fixed fan in (number of incomming connections) in each of the target neurons.

Parameters

n_fan_in	is the fan in that should be ensured.
synapse	Synapse object containing model and parameters
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the source population and ensures a fixed fan in (number of incomming connections) in each of the target neurons. Uses the given seed for the initialization of the random engine.

Parameters

n_fan_in	is the fan in that should be ensured.
weight	is the connection weight.
delay	is the synaptic delay.
seed	is the seed that should be used in order to initialize the random engine.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the source population and ensures a fixed fan in (number of incomming connections) in each of the target neurons. Uses the given seed for the initialization of the random engine.

Parameters

n_fan_in	is the fan in that should be ensured.
synapse	Synapse object containing model and parameters
seed	is the seed that should be used in order to initialize the random engine.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the target population and ensures a fixed fan out (number of outgoing connections) in each of the source neurons.

Parameters

n_fan_out	is the fan out that should be ensured.
weight	is the connection weight.
delay	is the synaptic delay.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the target population and ensures a fixed fan out (number of outgoing connections) in each of the source neurons.

Parameters

n_fan_out	is the fan out that should be ensured.
synapse	Synapse object containing model and parameters
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector which randomly selects neurons from the target population and ensures a fixed fan out (number of outgoing connections) in each of the source neurons. Uses the given seed for the initialization of the random engine.

Parameters

n_fan_out	is the fan out that should be ensured.
weight	is the connection weight.
delay	is the synaptic delay.
seed	is the seed that should be used in order to initialize the random engine.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

std::unique_ptr< FixedFanOutConnector< std::default_random_engine > > cypress::Connector::fixed_fan_out	(	size_t	n_fan_out,
		SynapseBase &	synapse,
		size_t	seed,
		bool	allow_self_connections = `true`
	)

inlinestaticinherited

Connector which randomly selects neurons from the target population and ensures a fixed fan out (number of outgoing connections) in each of the source neurons. Uses the given seed for the initialization of the random engine.

Parameters

n_fan_out	is the fan out that should be ensured.
synapse	Synapse object containing model and parameters
seed	is the seed that should be used in order to initialize the random engine.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

connector	another connector that should be modified by this connector.
p	probability with which an connection is created.

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

connector	another connector that should be modified by this connector.
p	probability with which an connection is created.
seed	is the seed the random number generator should be initialised with.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

std::unique_ptr< FromListConnector > cypress::Connector::from_list ( const std::vector< LocalConnection > & connections )

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

connections is a list of connections that should be created.

Returns: Unique pointer to the connector

std::unique_ptr< FromListConnector > cypress::Connector::from_list ( std::initializer_list< LocalConnection > connections )

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

connections is a list of connections that should be created.

Returns: Unique pointer to the connector

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

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

connections	is a list of connections that should be created.
synapse	prototype synapse for non-standard synapses

Returns: Unique pointer to the connector

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

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

connections	is a list of connections that should be created.
synapse	prototype synapse for non-standard synapses

Returns: Unique pointer to the connector

template<typename F >

std::unique_ptr< FunctorConnector< F > > cypress::Connector::functor ( const F & cback )

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

cback is a function which is called for each neuron-pair in the two populations and which is supposed to return a synapse description. If the returned synapse is invalid, no connection is created.

Returns: Unique pointer to the connector

template<typename F >

std::unique_ptr< UniformFunctorConnector< F > > cypress::Connector::functor	(	const F &	cback,
		Real	weight,
		Real	delay = `0.0`
	)

inlinestaticinherited

Create a list connector which creates connections according to the given list.

Parameters

cback	is a function which is called for each neuron-pair in the two populations and which is supposed to return a synapse description. If the returned synapse is invalid, no connection is created.
weight	is the synaptic weight that should be used for all connections.
delay	is the synaptic delay that should be used for all connections.

Returns: Unique pointer to the connector

template<typename RandomEngine >

template<typename F >

void cypress::FixedFanConnectorBase< RandomEngine >::generate_connections	(	size_t	offs,
		size_t	len,
		size_t	subset_len,
		size_t	i0,
		size_t	i1,
		const F &	f,
		bool	self
	)		const

inlineprotectedinherited

const std::vector<LocalConnection>& cypress::Connector::learned_weights ( ) const

inlineinherited

Returns a vector of (source, target, weight, delay) for learning synapses The returned structure can be used for a new FromListConnector...

template<typename RandomEngine >

std::string cypress::FixedFanInConnector< RandomEngine >::name ( ) const

inlineoverridevirtual

Function which should return a name identifying the connector type – this name can be used for printing error messages or for visualisation purposes.

Returns: a reference at a string describing the name of the descriptor type.

Implements cypress::Connector.

std::unique_ptr< OneToOneConnector > cypress::Connector::one_to_one	(	Real	weight = `1.0`,
		Real	delay = `0.0`
	)

inlinestaticinherited

Create a a one-to-one connector and returns a pointer at the connector.

Parameters

weight	is the synaptic weight that should be used for all connections.
delay	is the synaptic delay that should be used for all connections.

Returns: Unique pointer to the connector

std::unique_ptr< OneToOneConnector > cypress::Connector::one_to_one ( SynapseBase & synapse )

inlinestaticinherited

Creates an one-to-one connector and returns a pointer at the connector.

Parameters

synapse Synapse object containing model and parameters

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

weight	is the synaptic weight that should be used for all connections.
delay	is the synaptic delay that should be used for all connections.
probability	probability with which an connection is created.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

synapse	Synapse object containing model and parameters
probability	probability with which an connection is created.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

weight	is the synaptic weight that should be used for all connections.
delay	is the synaptic delay that should be used for all connections.
probability	probability with which an connection is created.
seed	is the seed the random number generator should be initialised with.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

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

inlinestaticinherited

Connector adapter which ensures connections are only produced with a certain probability.

Parameters

synapse	Synapse object containing model and parameters
probability	probability with which an connection is created.
seed	is the seed the random number generator should be initialised with.
allow_self_connections	Flag which either allows (true) or forbids self connections if the source and target population are the same

Returns: Unique pointer to the connector

template<typename RandomEngine >

void cypress::FixedFanConnectorBase< RandomEngine >::seed_given ( )

inlineinherited

Internally used to switch off backend connectors and use lists generated with the seed and random engine provided

template<typename RandomEngine >

size_t cypress::FixedFanInConnector< RandomEngine >::size	(	size_t	size_src_pop,
		size_t	size_target_pop
	)		const

inlineoverridevirtual

Returns the number of connections created with this connector and given pop sizes

Parameters

size_src_pop	Size of source population
size_target_pop	Size of target population

Returns: number of connections

Implements cypress::Connector.

const std::shared_ptr<SynapseBase> cypress::Connector::synapse ( ) const

inlineinherited

Returns a pointer to the underlying synapse object used in the connector

Returns: Shared-pointer to synapse

const std::string cypress::Connector::synapse_name ( ) const

inlineinherited

Directly access the name of the synapse model

Returns: string containing the name

template<typename RandomEngine >

bool cypress::FixedFanInConnector< RandomEngine >::valid ( const ConnectionDescriptor & descr ) const

inlineoverridevirtual

Checks the validity of the connection. For the FixedFanInConnector to be valid, the number of neurons in the source population must be at least equal to the fan in.

Implements cypress::Connector.

Member Data Documentation

Real cypress::Connector::m_additional_parameter = 0.0

protectedinherited

A additional parameter a connector might use (e.g. probability)

bool cypress::Connector::m_seed_given = false

protectedinherited

If a random connector is created with seed, we need this flag to not use the high level connectors of a backend, but generating connections here and using a list-connector

bool cypress::Connector::m_self_connections = true

protectedinherited

Flag for allowing neuron self connections if source and target population are identical

std::shared_ptr<SynapseBase> cypress::Connector::m_synapse

protectedinherited

Synapse model

std::vector<LocalConnection> cypress::Connector::m_weights

protectedinherited

This where learned weights are stored (e.g. using STDP)

The documentation for this class was generated from the following file:

cypress/core/connector.hpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<typename RandomEngine> class cypress::FixedFanInConnector< RandomEngine >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename RandomEngine>
class cypress::FixedFanInConnector< RandomEngine >