parameter.h

Go to the documentation of this file.

/*
 *  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 PARAMETER_H_
#define PARAMETER_H_
 
// C++ includes:
#include <cmath>
 
// Includes from nestkernel:
#include "generic_factory.h"
#include "nest_names.h"
#include "node.h"
#include "node_collection.h"
#include "random_generators.h"
 
 
namespace nest
{
class Parameter;
using ParameterPTR = std::shared_ptr< Parameter >;
 
class AbstractLayer;
 
class Parameter
{
public:
  Parameter( bool is_spatial = false, bool returns_int_only = false )
    : is_spatial_( is_spatial )
    , returns_int_only_( returns_int_only )
  {
  }
 
  explicit Parameter( const Parameter& p ) = default;
 
  virtual ~Parameter() = default;
 
  // TODO-PYNEST-NG: We need to either make this non-abstract or add every single non-abstract parameter subclass to the
  //  std::variant acceptec-types collection.
  virtual double
  value( RngPtr, Node* )
  {
    return 0.;
  }
 
  virtual double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node );
 
  std::vector< double > apply( const NodeCollectionPTR&, const std::vector< std::vector< double > >& );
 
  bool is_spatial() const;
 
  bool returns_int_only() const;
 
protected:
  bool is_spatial_ { false };
  bool returns_int_only_ { false };
 
  bool value_is_integer_( const double value ) const;
};
 
class ConstantParameter : public Parameter
{
public:
  using Parameter::value;
 
  explicit ConstantParameter( double value )
    : value_( value )
  {
    returns_int_only_ = value_is_integer_( value_ );
  }
 
  ConstantParameter( const Dictionary& d )
  {
    value_ = d.get< double >( "value" );
    returns_int_only_ = value_is_integer_( value_ );
  }
 
  ~ConstantParameter() override = default;
 
  double
  value( RngPtr, Node* ) override
  {
    return value_;
  }
 
private:
  double value_;
};
 
 
class UniformParameter : public Parameter
{
public:
  using Parameter::value;
 
  UniformParameter( const Dictionary& d )
    : lower_( 0.0 )
    , range_( 1.0 )
  {
    d.update_value( names::min, lower_ );
    d.update_value( names::max, range_ );
    if ( lower_ >= range_ )
    {
      throw BadProperty(
        "UniformParameter: "
        "min < max required." );
    }
 
    range_ -= lower_;
  }
 
  double
  value( RngPtr rng, Node* ) override
  {
    return lower_ + rng->drand() * range_;
  }
 
private:
  double lower_, range_;
};
 
class UniformIntParameter : public Parameter
{
public:
  using Parameter::value;
 
  UniformIntParameter( const Dictionary& d )
    : Parameter( false, true )
    , max_( 1 )
  {
    d.update_integer_value( names::max, max_ );
    if ( max_ <= 0 )
    {
      throw BadProperty( "UniformIntParameter: max > 0 required." );
    }
  }
 
  double
  value( RngPtr rng, Node* ) override
  {
    return rng->ulrand( max_ );
  }
 
private:
  long max_;
};
 
 
class NormalParameter : public Parameter
{
public:
  using Parameter::value;
 
  NormalParameter( const Dictionary& d );
 
  double value( RngPtr rng, Node* node ) override;
 
private:
  double mean_, std_;
  std::vector< normal_distribution > normal_dists_;
};
 
 
class LognormalParameter : public Parameter
{
public:
  using Parameter::value;
 
  LognormalParameter( const Dictionary& d );
 
  double value( RngPtr rng, Node* node ) override;
 
private:
  double mean_, std_;
  std::vector< lognormal_distribution > lognormal_dists_;
};
 
 
class ExponentialParameter : public Parameter
{
public:
  using Parameter::value;
 
  ExponentialParameter( const Dictionary& d )
    : beta_( 1.0 )
  {
    d.update_value( names::beta, beta_ );
    if ( beta_ < 0 )
    {
      throw BadProperty( "ExponentialParameter: beta ≥ 0 required." );
    }
  }
 
  double
  value( RngPtr rng, Node* ) override
  {
    return beta_ * ( -std::log( 1 - rng->drand() ) );
  }
 
private:
  double beta_;
};
 
 
class NodePosParameter : public Parameter
{
public:
  NodePosParameter( const Dictionary& d )
    : Parameter( true )
    , dimension_( 0 )
    , synaptic_endpoint_( 0 )
  {
    bool dimension_specified = d.update_integer_value( names::dimension, dimension_ );
    if ( not dimension_specified )
    {
      throw BadParameterValue( "Dimension must be specified when creating a node position parameter." );
    }
    if ( dimension_ < 0 )
    {
      throw BadParameterValue( "Node position parameter dimension cannot be negative." );
    }
    d.update_integer_value( names::synaptic_endpoint, synaptic_endpoint_ );
    if ( synaptic_endpoint_ < 0 or 2 < synaptic_endpoint_ )
    {
      throw BadParameterValue( "Synaptic endpoint must either be unspecified (0), source (1) or target (2)." );
    }
  }
 
  double
  value( RngPtr, Node* node ) override
  {
    if ( synaptic_endpoint_ != 0 )
    {
      throw BadParameterValue( "Source or target position parameter can only be used when connecting." );
    }
    if ( not node )
    {
      throw KernelException( "Node position parameter can only be used when connecting spatially distributed nodes." );
    }
    return get_node_pos_( node );
  }
 
  double
  value( RngPtr,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer&,
    Node* ) override
  {
    switch ( synaptic_endpoint_ )
    {
    case 0:
      throw BadParameterValue( "Node position parameter cannot be used when connecting." );
    case 1:
    {
      return source_pos[ dimension_ ];
    }
    case 2:
      return target_pos[ dimension_ ];
    }
    throw KernelException( "Wrong synaptic_endpoint_." );
  }
 
private:
  long dimension_;
  int synaptic_endpoint_;
 
  double get_node_pos_( Node* node ) const;
};
 
 
class SpatialDistanceParameter : public Parameter
{
public:
  SpatialDistanceParameter( const Dictionary& d )
    : Parameter( true )
    , dimension_( 0 )
  {
    d.update_integer_value( names::dimension, dimension_ );
    if ( dimension_ < 0 )
    {
      throw BadParameterValue( "Spatial distance parameter dimension cannot be negative." );
    }
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Spatial distance parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* ) override;
 
private:
  int dimension_;
};
 
 
class ProductParameter : public Parameter
{
public:
  ProductParameter( const ParameterPTR m1, const ParameterPTR m2 )
    : Parameter( m1->is_spatial() or m2->is_spatial(), m1->returns_int_only() and m2->returns_int_only() )
    , parameter1_( m1 )
    , parameter2_( m2 )
  {
  }
 
  ProductParameter( const ProductParameter& p )
    : Parameter( p )
    , parameter1_( p.parameter1_ )
    , parameter2_( p.parameter2_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return parameter1_->value( rng, node ) * parameter2_->value( rng, node );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return parameter1_->value( rng, source_pos, target_pos, layer, node )
      * parameter2_->value( rng, source_pos, target_pos, layer, node );
  }
 
protected:
  ParameterPTR const parameter1_;
  ParameterPTR const parameter2_;
};
 
class QuotientParameter : public Parameter
{
public:
  QuotientParameter( ParameterPTR m1, ParameterPTR m2 )
    : Parameter( m1->is_spatial() or m2->is_spatial(), m1->returns_int_only() and m2->returns_int_only() )
    , parameter1_( m1 )
    , parameter2_( m2 )
  {
  }
 
  QuotientParameter( const QuotientParameter& p )
    : Parameter( p )
    , parameter1_( p.parameter1_ )
    , parameter2_( p.parameter2_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return parameter1_->value( rng, node ) / parameter2_->value( rng, node );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return parameter1_->value( rng, source_pos, target_pos, layer, node )
      / parameter2_->value( rng, source_pos, target_pos, layer, node );
  }
 
protected:
  ParameterPTR const parameter1_;
  ParameterPTR const parameter2_;
};
 
class SumParameter : public Parameter
{
public:
  SumParameter( ParameterPTR m1, ParameterPTR m2 )
    : Parameter( m1->is_spatial() or m2->is_spatial(), m1->returns_int_only() and m2->returns_int_only() )
    , parameter1_( m1 )
    , parameter2_( m2 )
  {
  }
 
  SumParameter( const SumParameter& p )
    : Parameter( p )
    , parameter1_( p.parameter1_ )
    , parameter2_( p.parameter2_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return parameter1_->value( rng, node ) + parameter2_->value( rng, node );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return parameter1_->value( rng, source_pos, target_pos, layer, node )
      + parameter2_->value( rng, source_pos, target_pos, layer, node );
  }
 
protected:
  ParameterPTR const parameter1_;
  ParameterPTR const parameter2_;
};
 
class DifferenceParameter : public Parameter
{
public:
  DifferenceParameter( ParameterPTR m1, ParameterPTR m2 )
    : Parameter( m1->is_spatial() or m2->is_spatial(), m1->returns_int_only() and m2->returns_int_only() )
    , parameter1_( m1 )
    , parameter2_( m2 )
  {
  }
 
  DifferenceParameter( const DifferenceParameter& p )
    : Parameter( p )
    , parameter1_( p.parameter1_ )
    , parameter2_( p.parameter2_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return parameter1_->value( rng, node ) - parameter2_->value( rng, node );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return parameter1_->value( rng, source_pos, target_pos, layer, node )
      - parameter2_->value( rng, source_pos, target_pos, layer, node );
  }
 
protected:
  ParameterPTR const parameter1_;
  ParameterPTR const parameter2_;
};
 
class ComparingParameter : public Parameter
{
public:
  ComparingParameter( ParameterPTR m1, ParameterPTR m2, const Dictionary& d )
    : Parameter( m1->is_spatial() or m2->is_spatial(), true )
    , parameter1_( m1 )
    , parameter2_( m2 )
    , comparator_( -1 )
  {
    if ( not d.update_integer_value( names::comparator, comparator_ ) )
    {
      throw BadParameter( "A comparator has to be specified." );
    }
    if ( comparator_ < 0 or 5 < comparator_ )
    {
      throw BadParameter( "Comparator specification has to be in the range 0-5." );
    }
  }
 
  ComparingParameter( const ComparingParameter& p )
    : Parameter( p )
    , parameter1_( p.parameter1_ )
    , parameter2_( p.parameter2_ )
    , comparator_( p.comparator_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return compare_( parameter1_->value( rng, node ), parameter2_->value( rng, node ) );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return compare_( parameter1_->value( rng, source_pos, target_pos, layer, node ),
      parameter2_->value( rng, source_pos, target_pos, layer, node ) );
  }
 
protected:
  ParameterPTR const parameter1_;
  ParameterPTR const parameter2_;
 
private:
  bool
  compare_( double value_a, double value_b ) const
  {
    switch ( comparator_ )
    {
    case 0:
      return value_a < value_b;
    case 1:
      return value_a <= value_b;
    case 2:
      return value_a == value_b;
    case 3:
      return value_a != value_b;
    case 4:
      return value_a >= value_b;
    case 5:
      return value_a > value_b;
    }
    throw KernelException( "Wrong comparison operator." );
  }
 
  int comparator_;
};
 
 
class ConditionalParameter : public Parameter
{
public:
  ConditionalParameter( ParameterPTR condition, ParameterPTR if_true, ParameterPTR if_false )
    : Parameter( condition->is_spatial() or if_true->is_spatial() or if_false->is_spatial(),
        if_true->returns_int_only() and if_false->returns_int_only() )
    , condition_( condition )
    , if_true_( if_true )
    , if_false_( if_false )
  {
  }
 
  ConditionalParameter( const ConditionalParameter& p )
    : Parameter( p )
    , condition_( p.condition_ )
    , if_true_( p.if_true_ )
    , if_false_( p.if_false_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    if ( condition_->value( rng, node ) )
    {
      return if_true_->value( rng, node );
    }
    else
    {
      return if_false_->value( rng, node );
    }
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    if ( condition_->value( rng, source_pos, target_pos, layer, node ) )
    {
      return if_true_->value( rng, source_pos, target_pos, layer, node );
    }
    else
    {
      return if_false_->value( rng, source_pos, target_pos, layer, node );
    }
  }
 
protected:
  ParameterPTR const condition_;
  ParameterPTR const if_true_;
  ParameterPTR const if_false_;
};
 
 
class MinParameter : public Parameter
{
public:
  MinParameter( ParameterPTR p, const double other_value )
    : Parameter( p->is_spatial(), p->returns_int_only() and value_is_integer_( other_value ) )
    , p_( p )
    , other_value_( other_value )
  {
    assert( is_spatial_ == p->is_spatial() );
  }
 
  MinParameter( const MinParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , other_value_( p.other_value_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::min( p_->value( rng, node ), other_value_ );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::min( p_->value( rng, source_pos, target_pos, layer, node ), other_value_ );
  }
 
protected:
  ParameterPTR const p_;
  double other_value_;
};
 
 
class MaxParameter : public Parameter
{
public:
  MaxParameter( ParameterPTR p, const double other_value )
    : Parameter( p->is_spatial(), p->returns_int_only() and value_is_integer_( other_value ) )
    , p_( p )
    , other_value_( other_value )
  {
  }
 
  MaxParameter( const MaxParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , other_value_( p.other_value_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::max( p_->value( rng, node ), other_value_ );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::max( p_->value( rng, source_pos, target_pos, layer, node ), other_value_ );
  }
 
protected:
  ParameterPTR const p_;
  double other_value_;
};
 
 
class RedrawParameter : public Parameter
{
public:
  RedrawParameter( ParameterPTR p, const double min, const double max );
 
  RedrawParameter( const RedrawParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , min_( p.min_ )
    , max_( p.max_ )
    , max_redraws_( p.max_redraws_ )
  {
  }
 
  double value( RngPtr rng, Node* node ) override;
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  ParameterPTR const p_;
  double min_;
  double max_;
  const size_t max_redraws_;
};
 
 
class ExpParameter : public Parameter
{
public:
  ExpParameter( ParameterPTR p )
    : Parameter( p->is_spatial() )
    , p_( p )
  {
  }
 
  ExpParameter( const ExpParameter& p )
    : Parameter( p )
    , p_( p.p_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::exp( p_->value( rng, node ) );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::exp( p_->value( rng, source_pos, target_pos, layer, node ) );
  }
 
protected:
  ParameterPTR const p_;
};
 
 
class SinParameter : public Parameter
{
public:
  SinParameter( ParameterPTR p )
    : Parameter( p->is_spatial() )
    , p_( p )
  {
  }
 
  SinParameter( const SinParameter& p )
    : Parameter( p )
    , p_( p.p_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::sin( p_->value( rng, node ) );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::sin( p_->value( rng, source_pos, target_pos, layer, node ) );
  }
 
protected:
  ParameterPTR const p_;
};
 
class CosParameter : public Parameter
{
public:
  CosParameter( ParameterPTR p )
    : Parameter( p->is_spatial() )
    , p_( p )
  {
  }
 
  CosParameter( const CosParameter& p )
    : Parameter( p )
    , p_( p.p_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::cos( p_->value( rng, node ) );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::cos( p_->value( rng, source_pos, target_pos, layer, node ) );
  }
 
protected:
  ParameterPTR const p_;
};
 
 
class PowParameter : public Parameter
{
public:
  PowParameter( ParameterPTR p, const double exponent )
    : Parameter( p->is_spatial(), p->returns_int_only() )
    , p_( p )
    , exponent_( exponent )
  {
  }
 
  PowParameter( const PowParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , exponent_( p.exponent_ )
  {
  }
 
  double
  value( RngPtr rng, Node* node ) override
  {
    return std::pow( p_->value( rng, node ), exponent_ );
  }
 
  double
  value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override
  {
    return std::pow( p_->value( rng, source_pos, target_pos, layer, node ), exponent_ );
  }
 
protected:
  ParameterPTR const p_;
  const double exponent_;
};
 
 
class DimensionParameter : public Parameter
{
public:
  using Parameter::value;
 
  DimensionParameter( ParameterPTR px, ParameterPTR py )
    : Parameter( true )
    , num_dimensions_( 2 )
    , px_( px )
    , py_( py )
    , pz_( nullptr )
  {
  }
 
  DimensionParameter( ParameterPTR px, ParameterPTR py, ParameterPTR pz )
    : Parameter( true )
    , num_dimensions_( 3 )
    , px_( px )
    , py_( py )
    , pz_( pz )
  {
  }
 
  DimensionParameter( const DimensionParameter& p )
    : Parameter( p )
    , num_dimensions_( p.num_dimensions_ )
    , px_( p.px_ )
    , py_( p.py_ )
    , pz_( p.pz_ )
  {
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw KernelException( "Cannot get value of DimensionParameter." );
  }
 
  std::vector< double >
  get_values( RngPtr rng )
  {
    switch ( num_dimensions_ )
    {
    case 2:
      return { px_->value( rng, nullptr ), py_->value( rng, nullptr ) };
    case 3:
      return { px_->value( rng, nullptr ), py_->value( rng, nullptr ), pz_->value( rng, nullptr ) };
    }
    throw KernelException( "Wrong number of dimensions in get_values!" );
  }
 
  int
  get_num_dimensions() const
  {
    return num_dimensions_;
  }
 
protected:
  int num_dimensions_;
  ParameterPTR const px_;
  ParameterPTR const py_;
  ParameterPTR const pz_;
};
 
 
class ExpDistParameter : public Parameter
{
public:
  using Parameter::value;
 
  ExpDistParameter( const Dictionary& d );
 
  ExpDistParameter( const ExpDistParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , inv_beta_( p.inv_beta_ )
  {
    assert( is_spatial_ == p.is_spatial() );
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Exponential distribution parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  ParameterPTR const p_;
  const double inv_beta_;
};
 
 
class GaussianParameter : public Parameter
{
public:
  using Parameter::value;
 
  GaussianParameter( const Dictionary& d );
 
  GaussianParameter( const GaussianParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , mean_( p.mean_ )
    , inv_two_std2_( p.inv_two_std2_ )
  {
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Gaussian distribution parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  ParameterPTR const p_;
  const double mean_;
  const double inv_two_std2_;
};
 
 
class Gaussian2DParameter : public Parameter
{
public:
  using Parameter::value;
 
  Gaussian2DParameter( const Dictionary& d );
 
  Gaussian2DParameter( const Gaussian2DParameter& p )
    : Parameter( p )
    , px_( p.px_ )
    , py_( p.py_ )
    , mean_x_( p.mean_x_ )
    , mean_y_( p.mean_y_ )
    , x_term_const_( p.x_term_const_ )
    , y_term_const_( p.y_term_const_ )
    , xy_term_const_( p.xy_term_const_ )
  {
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Gaussian 2D parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  ParameterPTR const px_;
  ParameterPTR const py_;
  const double mean_x_;
  const double mean_y_;
  const double x_term_const_;
  const double y_term_const_;
  const double xy_term_const_;
};
 
class GaborParameter : public Parameter
{
public:
  using Parameter::value;
 
  GaborParameter( const Dictionary& d );
 
  GaborParameter( const GaborParameter& p )
    : Parameter( p )
    , px_( p.px_ )
    , py_( p.py_ )
    , cos_( p.cos_ )
    , sin_( p.sin_ )
    , gamma_( p.gamma_ )
    , inv_two_std2_( p.inv_two_std2_ )
    , lambda_( p.lambda_ )
    , psi_( p.psi_ )
  {
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Gabor parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  std::shared_ptr< Parameter > const px_;
  std::shared_ptr< Parameter > const py_;
  const double cos_;
  const double sin_;
  const double gamma_;
  const double inv_two_std2_;
  const double lambda_;
  const double psi_;
};
 
 
class GammaParameter : public Parameter
{
public:
  using Parameter::value;
 
  GammaParameter( const Dictionary& d );
 
  GammaParameter( const GammaParameter& p )
    : Parameter( p )
    , p_( p.p_ )
    , kappa_( p.kappa_ )
    , inv_theta_( p.inv_theta_ )
    , delta_( p.delta_ )
  {
  }
 
  double
  value( RngPtr, Node* ) override
  {
    throw BadParameterValue( "Gamma distribution parameter can only be used when connecting." );
  }
 
  double value( RngPtr rng,
    const std::vector< double >& source_pos,
    const std::vector< double >& target_pos,
    const AbstractLayer& layer,
    Node* node ) override;
 
protected:
  ParameterPTR const p_;
  const double kappa_;
  const double inv_theta_;
  const double delta_;
};
 
inline double
Parameter::value( RngPtr rng,
  const std::vector< double >&,
  const std::vector< double >&,
  const AbstractLayer&,
  Node* node )
{
  return value( rng, node );
}
 
inline bool
Parameter::is_spatial() const
{
  return is_spatial_;
}
 
inline bool
Parameter::returns_int_only() const
{
  return returns_int_only_;
}
 
inline bool
Parameter::value_is_integer_( const double value ) const
{
  // Here fmod calculates the remainder of the division operation x/y. By using y=1.0, the remainder is the
  // fractional part of the value. If the fractional part is zero, the value is an integer.
  return std::fmod( value, static_cast< double >( 1.0 ) ) == 0.0;
}
 
 
ParameterPTR multiply_parameter( const ParameterPTR first, const ParameterPTR second );
 
ParameterPTR divide_parameter( const ParameterPTR first, const ParameterPTR second );
 
ParameterPTR add_parameter( const ParameterPTR first, const ParameterPTR second );
 
ParameterPTR subtract_parameter( const ParameterPTR first, const ParameterPTR second );
 
ParameterPTR compare_parameter( const ParameterPTR first, const ParameterPTR second, const Dictionary& d );
 
ParameterPTR
conditional_parameter( const ParameterPTR condition, const ParameterPTR if_true, const ParameterPTR if_false );
 
ParameterPTR min_parameter( const ParameterPTR parameter, const double other );
 
ParameterPTR max_parameter( const ParameterPTR parameter, const double other );
 
ParameterPTR redraw_parameter( const ParameterPTR parameter, const double min, const double max );
 
ParameterPTR exp_parameter( const ParameterPTR parameter );
 
ParameterPTR sin_parameter( const ParameterPTR parameter );
 
ParameterPTR cos_parameter( const ParameterPTR parameter );
 
ParameterPTR pow_parameter( const ParameterPTR parameter, const double exponent );
 
ParameterPTR dimension_parameter( const ParameterPTR x_parameter, const ParameterPTR y_parameter );
 
ParameterPTR
dimension_parameter( const ParameterPTR x_parameter, const ParameterPTR y_parameter, const ParameterPTR z_parameter );
 
 
}  // namespace nest
 
#endif