conn_parameter.h

Go to the documentation of this file.

/*
 *  conn_parameter.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST 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 NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef CONN_PARAMETER_H
#define CONN_PARAMETER_H
 
// C++ includes:
#include <limits>
#include <vector>
 
// Includes from nestkernel:
#include "exceptions.h"
#include "parameter.h"
 
namespace nest
{
 
class ConnParameter
{
 
public:
  ConnParameter()
  {
  }
 
  virtual ~ConnParameter()
  {
  }
 
  virtual double value_double( size_t, RngPtr, size_t, Node* ) const = 0;
  virtual long value_int( size_t, RngPtr, size_t, Node* ) const = 0;
  virtual void
  skip( size_t, size_t ) const
  {
  }
  virtual bool is_array() const = 0;
 
  virtual bool
  is_scalar() const
  {
    return false;
  }
 
  virtual bool
  provides_long() const
  {
    return false;
  }
 
  virtual void
  reset() const
  {
    throw NotImplemented( "Symmetric connections require parameters that can be reset." );
  }
 
  virtual size_t
  number_of_values() const
  {
    return 0;
  }
 
  static ConnParameter* create( const any_type&, const size_t );
};
 
 
class ScalarDoubleParameter : public ConnParameter
{
public:
  ScalarDoubleParameter( double value, const size_t )
    : value_( value )
  {
  }
 
  double
  value_double( size_t, RngPtr, size_t, Node* ) const override
  {
    return value_;
  }
 
  long
  value_int( size_t, RngPtr, size_t, Node* ) const override
  {
    throw KernelException( "ConnParameter calls value function with false return type." );
  }
 
  inline bool
  is_array() const override
  {
    return false;
  }
 
  void
  reset() const override
  {
  }
 
  bool
  is_scalar() const override
  {
    return true;
  }
 
private:
  double value_;
};
 
class ScalarIntegerParameter : public ConnParameter
{
public:
  ScalarIntegerParameter( long value, const size_t )
    : value_( value )
  {
  }
 
  double
  value_double( size_t, RngPtr, size_t, Node* ) const override
  {
    return static_cast< double >( value_ );
  }
 
  long
  value_int( size_t, RngPtr, size_t, Node* ) const override
  {
    return value_;
  }
 
  inline bool
  is_array() const override
  {
    return false;
  }
 
  void
  reset() const override
  {
  }
 
  bool
  is_scalar() const override
  {
    return true;
  }
 
  bool
  provides_long() const override
  {
    return true;
  }
 
private:
  long value_;
};
 
 
class ArrayDoubleParameter : public ConnParameter
{
public:
  ArrayDoubleParameter( const std::vector< double >& values, const size_t nthreads )
    : values_( values )
    , next_( nthreads, values_.begin() )
  {
  }
 
  void
  skip( size_t tid, size_t n_skip ) const override
  {
    if ( next_[ tid ] < values_.end() )
    {
      next_[ tid ] += n_skip;
    }
    else
    {
      throw KernelException( "Parameter values exhausted." );
    }
  }
 
  size_t
  number_of_values() const override
  {
    return values_.size();
  }
 
  double
  value_double( size_t tid, RngPtr, size_t, Node* ) const override
  {
    if ( next_[ tid ] != values_.end() )
    {
      return *next_[ tid ]++;
    }
    else
    {
      throw KernelException( "Parameter values exhausted." );
    }
  }
 
  long
  value_int( size_t, RngPtr, size_t, Node* ) const override
  {
    throw KernelException( "ConnParameter calls value function with false return type." );
  }
 
  inline bool
  is_array() const override
  {
    return true;
  }
 
  void
  reset() const override
  {
    for ( std::vector< std::vector< double >::const_iterator >::iterator it = next_.begin(); it != next_.end(); ++it )
    {
      *it = values_.begin();
    }
  }
 
private:
  const std::vector< double > values_;
  mutable std::vector< std::vector< double >::const_iterator > next_;
};
 
class ArrayLongParameter : public ConnParameter
{
public:
  ArrayLongParameter( const std::vector< long >& values, const size_t nthreads )
    : values_( values )
    , next_( nthreads, values_.begin() )
  {
  }
 
  void
  skip( size_t tid, size_t n_skip ) const override
  {
    if ( next_[ tid ] < values_.end() )
    {
      next_[ tid ] += n_skip;
    }
    else
    {
      throw KernelException( "Parameter values exhausted." );
    }
  }
 
  size_t
  number_of_values() const override
  {
    return values_.size();
  }
 
  long
  value_int( size_t tid, RngPtr, size_t, Node* ) const override
  {
    if ( next_[ tid ] != values_.end() )
    {
      return *next_[ tid ]++;
    }
    else
    {
      throw KernelException( "Parameter values exhausted." );
    }
  }
 
  double
  value_double( size_t tid, RngPtr, size_t, Node* ) const override
  {
    if ( next_[ tid ] != values_.end() )
    {
      return static_cast< double >( *next_[ tid ]++ );
    }
    else
    {
      throw KernelException( "Parameter values exhausted." );
    }
  }
 
  inline bool
  is_array() const override
  {
    return true;
  }
 
  bool
  provides_long() const override
  {
    return true;
  }
 
  void
  reset() const override
  {
    for ( std::vector< std::vector< long >::const_iterator >::iterator it = next_.begin(); it != next_.end(); ++it )
    {
      *it = values_.begin();
    }
  }
 
private:
  const std::vector< long > values_;
  mutable std::vector< std::vector< long >::const_iterator > next_;
};
 
class ParameterConnParameterWrapper : public ConnParameter
{
public:
  ParameterConnParameterWrapper( ParameterPTR, const size_t );
 
  double value_double( size_t target_thread, RngPtr rng, size_t snode_id, Node* target ) const override;
 
  long
  value_int( size_t target_thread, RngPtr rng, size_t snode_id, Node* target ) const override
  {
    return value_double( target_thread, rng, snode_id, target );
  }
 
  inline bool
  is_array() const override
  {
    return false;
  }
 
  bool
  provides_long() const override
  {
    return parameter_->returns_int_only();
  }
 
private:
  ParameterPTR parameter_;
};
 
}  // namespace nest
 
#endif