From 33430f3653a4616452b745b84b14e88b88d2d294 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 16 Feb 2022 22:32:59 +0100 Subject: [PATCH 001/150] Minor clean-up of includes --- models/modelsmodule.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 7d317a7cc7..441a561d6e 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -22,12 +22,20 @@ #include "modelsmodule.h" -// Includes from nestkernel +// Includes from nestkernel: +#include "common_synapse_properties.h" +#include "connector_model_impl.h" +#include "genericmodel.h" #include "genericmodel_impl.h" +#include "kernel_manager.h" +#include "model.h" +#include "model_manager_impl.h" +#include "target_identifier.h" // Generated includes: #include "config.h" + // Neuron models #include "aeif_cond_alpha.h" #include "aeif_cond_alpha_multisynapse.h" @@ -147,15 +155,6 @@ #include "urbanczik_synapse.h" #include "vogels_sprekeler_synapse.h" -// Includes from nestkernel: -#include "common_synapse_properties.h" -#include "connector_model_impl.h" -#include "genericmodel.h" -#include "kernel_manager.h" -#include "model.h" -#include "model_manager_impl.h" -#include "target_identifier.h" - #ifdef HAVE_MUSIC #include "music_cont_in_proxy.h" #include "music_cont_out_proxy.h" @@ -166,6 +165,7 @@ #include "music_rate_out_proxy.h" #endif + namespace nest { // At the time when ModelsModule is constructed, the SLI Interpreter @@ -336,7 +336,6 @@ ModelsModule::init( SLIInterpreter* ) // register secondary connection models register_secondary_connection_model< GapJunction >( "gap_junction", RegisterConnectionModelFlags::REQUIRES_SYMMETRIC | RegisterConnectionModelFlags::SUPPORTS_WFR ); - register_secondary_connection_model< RateConnectionInstantaneous >( "rate_connection_instantaneous", RegisterConnectionModelFlags::SUPPORTS_WFR ); register_secondary_connection_model< RateConnectionDelayed >( From 003a33997bbea612023404bcadedd5a9a06859ad Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Thu, 17 Feb 2022 18:10:38 +0100 Subject: [PATCH 002/150] Move SecondaryEvent classes to their own file --- nestkernel/CMakeLists.txt | 1 + nestkernel/clopath_archiving_node.cpp | 1 + nestkernel/connector_model.h | 1 + nestkernel/event.h | 431 ------------------------ nestkernel/event_delivery_manager.h | 1 + nestkernel/node.h | 4 +- nestkernel/secondary_event.h | 462 ++++++++++++++++++++++++++ 7 files changed, 468 insertions(+), 433 deletions(-) create mode 100644 nestkernel/secondary_event.h diff --git a/nestkernel/CMakeLists.txt b/nestkernel/CMakeLists.txt index 916fd92bf2..6818b195c5 100644 --- a/nestkernel/CMakeLists.txt +++ b/nestkernel/CMakeLists.txt @@ -59,6 +59,7 @@ set ( nestkernel_sources recording_device.h recording_device.cpp pseudo_recording_device.h ring_buffer.h ring_buffer_impl.h ring_buffer.cpp + secondary_event.h slice_ring_buffer.cpp slice_ring_buffer.h spikecounter.h spikecounter.cpp stimulation_device.h stimulation_device.cpp diff --git a/nestkernel/clopath_archiving_node.cpp b/nestkernel/clopath_archiving_node.cpp index 4617c78829..5f20ed84c5 100644 --- a/nestkernel/clopath_archiving_node.cpp +++ b/nestkernel/clopath_archiving_node.cpp @@ -24,6 +24,7 @@ // Includes from nestkernel: #include "kernel_manager.h" +#include "secondary_event.h" // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/connector_model.h b/nestkernel/connector_model.h index 83169c87e4..716d484d4d 100644 --- a/nestkernel/connector_model.h +++ b/nestkernel/connector_model.h @@ -34,6 +34,7 @@ #include "event.h" #include "nest_time.h" #include "nest_types.h" +#include "secondary_event.h" // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/event.h b/nestkernel/event.h index 2da8eee3db..a4654dc958 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -826,437 +826,6 @@ DoubleDataEvent::clone() const return new DoubleDataEvent( *this ); } -/** - * Base class of secondary events. Provides interface for - * serialization and deserialization. This event type may be - * used to transmit data on a regular basis - * Further information about secondary events and - * their usage with gap junctions can be found in - * - * Hahne, J., Helias, M., Kunkel, S., Igarashi, J., - * Bolten, M., Frommer, A. and Diesmann, M., - * A unified framework for spiking and gap-junction interactions - * in distributed neuronal network simulations, - * Front. Neuroinform. 9:22. (2015), - * doi: 10.3389/fninf.2015.00022 - */ -class SecondaryEvent : public Event -{ - -public: - virtual SecondaryEvent* clone() const = 0; - - virtual void add_syn_id( const synindex synid ) = 0; - - virtual bool supports_syn_id( const synindex synid ) const = 0; - - //! size of event in units of unsigned int - virtual size_t size() = 0; - virtual std::vector< unsigned int >::iterator& operator<<( std::vector< unsigned int >::iterator& pos ) = 0; - virtual std::vector< unsigned int >::iterator& operator>>( std::vector< unsigned int >::iterator& pos ) = 0; - - virtual const std::vector< synindex >& get_supported_syn_ids() const = 0; - - virtual void reset_supported_syn_ids() = 0; -}; - -/** - * This template function returns the number of uints covered by a variable of - * type T. This function is used to determine the storage demands for a - * variable of type T in the NEST communication buffer, which is of type - * std::vector. - */ -template < typename T > -size_t -number_of_uints_covered( void ) -{ - size_t num_uints = sizeof( T ) / sizeof( unsigned int ); - if ( num_uints * sizeof( unsigned int ) < sizeof( T ) ) - { - num_uints += 1; - } - return num_uints; -} - -/** - * This template function writes data of type T to a given position of a - * std::vector< unsigned int >. - * Please note that this function does not increase the size of the vector, - * it just writes the data to the position given by the iterator. - * The function is used to write data from SecondaryEvents to the NEST - * communication buffer. The pos iterator is advanced during execution. - * For a discussion on the functionality of this function see github issue #181 - * and pull request #184. - */ -template < typename T > -void -write_to_comm_buffer( T d, std::vector< unsigned int >::iterator& pos ) -{ - // there is no aliasing problem here, since cast to char* invalidate strict - // aliasing assumptions - char* const c = reinterpret_cast< char* >( &d ); - - const size_t num_uints = number_of_uints_covered< T >(); - size_t left_to_copy = sizeof( T ); - - for ( size_t i = 0; i < num_uints; i++ ) - { - memcpy( &( *( pos + i ) ), c + i * sizeof( unsigned int ), std::min( left_to_copy, sizeof( unsigned int ) ) ); - left_to_copy -= sizeof( unsigned int ); - } - - pos += num_uints; -} - -/** - * This template function reads data of type T from a given position of a - * std::vector< unsigned int >. The function is used to read SecondaryEvents - * data from the NEST communication buffer. The pos iterator is advanced - * during execution. For a discussion on the functionality of this function see - * github issue #181 and pull request #184. - */ -template < typename T > -void -read_from_comm_buffer( T& d, std::vector< unsigned int >::iterator& pos ) -{ - // there is no aliasing problem here, since cast to char* invalidate strict - // aliasing assumptions - char* const c = reinterpret_cast< char* >( &d ); - - const size_t num_uints = number_of_uints_covered< T >(); - size_t left_to_copy = sizeof( T ); - - for ( size_t i = 0; i < num_uints; i++ ) - { - memcpy( c + i * sizeof( unsigned int ), &( *( pos + i ) ), std::min( left_to_copy, sizeof( unsigned int ) ) ); - left_to_copy -= sizeof( unsigned int ); - } - - pos += num_uints; -} - -/** - * Template class for the storage and communication of a std::vector of type - * DataType. The class provides the functionality to communicate homogeneous - * data of type DataType. The second template type Subclass (which should be - * chosen as the derived class itself) is used to distinguish derived classes - * with the same DataType. This is required because of the included static - * variables in the base class (as otherwise all derived classes with the same - * DataType would share the same static variables). - * - * Technically the DataSecondaryEvent only contains iterators pointing to - * the memory location of the std::vector< DataType >. - * - * Conceptually, there is a one-to-one mapping between a SecondaryEvent - * and a SecondaryConnectorModel. The synindex of this particular - * SecondaryConnectorModel is stored as first element in the static vector - * supported_syn_ids_ on model registration. There are however reasons (e.g. - * the usage of CopyModel or the creation of the labeled synapse model - * duplicates for pyNN) which make it necessary to register several - * SecondaryConnectorModels with one SecondaryEvent. Therefore the synindices - * of all these models are added to supported_syn_ids_. The - * supports_syn_id()-function allows testing if a particular synid is mapped - * with the SecondaryEvent in question. - */ -template < typename DataType, typename Subclass > -class DataSecondaryEvent : public SecondaryEvent -{ -private: - // we chose std::vector over std::set because we expect this to be short - static std::vector< synindex > pristine_supported_syn_ids_; - static std::vector< synindex > supported_syn_ids_; - static size_t coeff_length_; // length of coeffarray - - union CoeffarrayBegin { - std::vector< unsigned int >::iterator as_uint; - typename std::vector< DataType >::iterator as_d; - - CoeffarrayBegin() {}; // need to provide default constructor due to - // non-trivial constructors of iterators - } coeffarray_begin_; - - union CoeffarrayEnd { - std::vector< unsigned int >::iterator as_uint; - typename std::vector< DataType >::iterator as_d; - - CoeffarrayEnd() {}; // need to provide default constructor due to - // non-trivial constructors of iterators - } coeffarray_end_; - -public: - /** - * This function is needed to set the synid on model registration. - * At this point no object of this type is available and the - * add_syn_id-function cannot be used as it is virtual in the base class - * and therefore cannot be declared as static. - */ - static void - set_syn_id( const synindex synid ) - { - VPManager::assert_single_threaded(); - pristine_supported_syn_ids_.push_back( synid ); - supported_syn_ids_.push_back( synid ); - } - - /** - * This function is needed to add additional synids when the - * corresponded connector model is copied. - * This function needs to be a virtual function of the base class as - * it is called from a pointer on SecondaryEvent. - */ - void - add_syn_id( const synindex synid ) - { - assert( not supports_syn_id( synid ) ); - VPManager::assert_single_threaded(); - supported_syn_ids_.push_back( synid ); - } - - const std::vector< synindex >& - get_supported_syn_ids() const - { - return supported_syn_ids_; - } - - /** - * Resets the vector of supported syn ids to those originally - * registered via ModelsModule or user defined Modules, i.e., - * removes all syn ids created by CopyModel. This is important to - * maintain consistency across ResetKernel, which removes all copied - * models. - */ - void - reset_supported_syn_ids() - { - supported_syn_ids_.clear(); - for ( size_t i = 0; i < pristine_supported_syn_ids_.size(); ++i ) - { - supported_syn_ids_.push_back( pristine_supported_syn_ids_[ i ] ); - } - } - - static void - set_coeff_length( const size_t coeff_length ) - { - VPManager::assert_single_threaded(); - coeff_length_ = coeff_length; - } - - bool - supports_syn_id( const synindex synid ) const - { - return ( std::find( supported_syn_ids_.begin(), supported_syn_ids_.end(), synid ) != supported_syn_ids_.end() ); - } - - void - set_coeffarray( std::vector< DataType >& ca ) - { - coeffarray_begin_.as_d = ca.begin(); - coeffarray_end_.as_d = ca.end(); - assert( coeff_length_ == ca.size() ); - } - - /** - * The following operator is used to read the information of the - * DataSecondaryEvent from the buffer in EventDeliveryManager::deliver_events - */ - std::vector< unsigned int >::iterator& - operator<<( std::vector< unsigned int >::iterator& pos ) - { - // The synid can be skipped here as it is stored in a static vector - - // generating a copy of the coeffarray is too time consuming - // therefore we save an iterator to the beginning+end of the coeffarray - coeffarray_begin_.as_uint = pos; - - pos += coeff_length_ * number_of_uints_covered< DataType >(); - - coeffarray_end_.as_uint = pos; - - return pos; - } - - /** - * The following operator is used to write the information of the - * DataSecondaryEvent into the secondary_events_buffer_. - * All DataSecondaryEvents are identified by the synid of the - * first element in supported_syn_ids_. - */ - std::vector< unsigned int >::iterator& - operator>>( std::vector< unsigned int >::iterator& pos ) - { - for ( typename std::vector< DataType >::iterator it = coeffarray_begin_.as_d; it != coeffarray_end_.as_d; ++it ) - { - // we need the static_cast here as the size of a stand-alone variable - // and a std::vector entry may differ (e.g. for std::vector< bool >) - write_to_comm_buffer( static_cast< DataType >( *it ), pos ); - } - return pos; - } - - size_t - size() - { - size_t s = number_of_uints_covered< synindex >(); - s += number_of_uints_covered< index >(); - s += number_of_uints_covered< DataType >() * coeff_length_; - - return s; - } - - const std::vector< unsigned int >::iterator& - begin() - { - return coeffarray_begin_.as_uint; - } - - const std::vector< unsigned int >::iterator& - end() - { - return coeffarray_end_.as_uint; - } - - DataType get_coeffvalue( std::vector< unsigned int >::iterator& pos ); -}; - -/** - * Event for gap-junction information. The event transmits the interpolation - * of the membrane potential to the connected neurons. - */ -class GapJunctionEvent : public DataSecondaryEvent< double, GapJunctionEvent > -{ - -public: - GapJunctionEvent() - { - } - - void operator()(); - GapJunctionEvent* clone() const; -}; - -/** - * Event for rate model connections without delay. The event transmits - * the rate to the connected neurons. - */ -class InstantaneousRateConnectionEvent : public DataSecondaryEvent< double, InstantaneousRateConnectionEvent > -{ - -public: - InstantaneousRateConnectionEvent() - { - } - - void operator()(); - InstantaneousRateConnectionEvent* clone() const; -}; - -/** - * Event for rate model connections with delay. The event transmits - * the rate to the connected neurons. - */ -class DelayedRateConnectionEvent : public DataSecondaryEvent< double, DelayedRateConnectionEvent > -{ - -public: - DelayedRateConnectionEvent() - { - } - - void operator()(); - DelayedRateConnectionEvent* clone() const; -}; - -/** - * Event for diffusion connections (rate model connections for the - * siegert_neuron). The event transmits the rate to the connected neurons. - */ -class DiffusionConnectionEvent : public DataSecondaryEvent< double, DiffusionConnectionEvent > -{ -private: - // drift factor of the corresponding connection - weight drift_factor_; - // diffusion factor of the corresponding connection - weight diffusion_factor_; - -public: - DiffusionConnectionEvent() - { - } - - void operator()(); - DiffusionConnectionEvent* clone() const; - - void - set_diffusion_factor( weight t ) - { - diffusion_factor_ = t; - }; - - void - set_drift_factor( weight t ) - { - drift_factor_ = t; - }; - - weight get_drift_factor() const; - weight get_diffusion_factor() const; -}; - -template < typename DataType, typename Subclass > -inline DataType -DataSecondaryEvent< DataType, Subclass >::get_coeffvalue( std::vector< unsigned int >::iterator& pos ) -{ - DataType elem; - read_from_comm_buffer( elem, pos ); - return elem; -} - -template < typename Datatype, typename Subclass > -std::vector< synindex > DataSecondaryEvent< Datatype, Subclass >::pristine_supported_syn_ids_; - -template < typename DataType, typename Subclass > -std::vector< synindex > DataSecondaryEvent< DataType, Subclass >::supported_syn_ids_; - -template < typename DataType, typename Subclass > -size_t DataSecondaryEvent< DataType, Subclass >::coeff_length_ = 0; - -inline GapJunctionEvent* -GapJunctionEvent::clone() const -{ - return new GapJunctionEvent( *this ); -} - -inline InstantaneousRateConnectionEvent* -InstantaneousRateConnectionEvent::clone() const -{ - return new InstantaneousRateConnectionEvent( *this ); -} - -inline DelayedRateConnectionEvent* -DelayedRateConnectionEvent::clone() const -{ - return new DelayedRateConnectionEvent( *this ); -} - -inline DiffusionConnectionEvent* -DiffusionConnectionEvent::clone() const -{ - return new DiffusionConnectionEvent( *this ); -} - -inline weight -DiffusionConnectionEvent::get_drift_factor() const -{ - return drift_factor_; -} - -inline weight -DiffusionConnectionEvent::get_diffusion_factor() const -{ - return diffusion_factor_; -} - //************************************************************* // Inline implementations. diff --git a/nestkernel/event_delivery_manager.h b/nestkernel/event_delivery_manager.h index 555baf8ce8..5f7981234b 100644 --- a/nestkernel/event_delivery_manager.h +++ b/nestkernel/event_delivery_manager.h @@ -39,6 +39,7 @@ #include "nest_types.h" #include "node.h" #include "per_thread_bool_indicator.h" +#include "secondary_event.h" #include "spike_data.h" #include "target_table.h" #include "vp_manager.h" diff --git a/nestkernel/node.h b/nestkernel/node.h index 3381e0942a..c2487b97c2 100644 --- a/nestkernel/node.h +++ b/nestkernel/node.h @@ -32,14 +32,14 @@ #include // Includes from nestkernel: +#include "deprecation_warning.h" #include "event.h" #include "histentry.h" #include "nest_names.h" #include "nest_time.h" #include "nest_types.h" #include "node_collection.h" - -#include "deprecation_warning.h" +#include "secondary_event.h" // Includes from sli: #include "dictdatum.h" diff --git a/nestkernel/secondary_event.h b/nestkernel/secondary_event.h new file mode 100644 index 0000000000..54d39a5c82 --- /dev/null +++ b/nestkernel/secondary_event.h @@ -0,0 +1,462 @@ +/* + * secondary_event.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 . + * + */ + +#ifndef SECONDARY_EVENT_H +#define SECONDARY_EVENT_H + +namespace nest +{ + +/** + * Base class of secondary events. Provides interface for + * serialization and deserialization. This event type may be + * used to transmit data on a regular basis + * Further information about secondary events and + * their usage with gap junctions can be found in + * + * Hahne, J., Helias, M., Kunkel, S., Igarashi, J., + * Bolten, M., Frommer, A. and Diesmann, M., + * A unified framework for spiking and gap-junction interactions + * in distributed neuronal network simulations, + * Front. Neuroinform. 9:22. (2015), + * doi: 10.3389/fninf.2015.00022 + */ +class SecondaryEvent : public Event +{ + +public: + virtual SecondaryEvent* clone() const = 0; + + virtual void add_syn_id( const synindex synid ) = 0; + + virtual bool supports_syn_id( const synindex synid ) const = 0; + + //! size of event in units of unsigned int + virtual size_t size() = 0; + virtual std::vector< unsigned int >::iterator& operator<<( std::vector< unsigned int >::iterator& pos ) = 0; + virtual std::vector< unsigned int >::iterator& operator>>( std::vector< unsigned int >::iterator& pos ) = 0; + + virtual const std::vector< synindex >& get_supported_syn_ids() const = 0; + + virtual void reset_supported_syn_ids() = 0; +}; + +/** + * This template function returns the number of uints covered by a variable of + * type T. This function is used to determine the storage demands for a + * variable of type T in the NEST communication buffer, which is of type + * std::vector. + */ +template < typename T > +size_t +number_of_uints_covered( void ) +{ + size_t num_uints = sizeof( T ) / sizeof( unsigned int ); + if ( num_uints * sizeof( unsigned int ) < sizeof( T ) ) + { + num_uints += 1; + } + return num_uints; +} + +/** + * This template function writes data of type T to a given position of a + * std::vector< unsigned int >. + * Please note that this function does not increase the size of the vector, + * it just writes the data to the position given by the iterator. + * The function is used to write data from SecondaryEvents to the NEST + * communication buffer. The pos iterator is advanced during execution. + * For a discussion on the functionality of this function see github issue #181 + * and pull request #184. + */ +template < typename T > +void +write_to_comm_buffer( T d, std::vector< unsigned int >::iterator& pos ) +{ + // there is no aliasing problem here, since cast to char* invalidate strict + // aliasing assumptions + char* const c = reinterpret_cast< char* >( &d ); + + const size_t num_uints = number_of_uints_covered< T >(); + size_t left_to_copy = sizeof( T ); + + for ( size_t i = 0; i < num_uints; i++ ) + { + memcpy( &( *( pos + i ) ), c + i * sizeof( unsigned int ), std::min( left_to_copy, sizeof( unsigned int ) ) ); + left_to_copy -= sizeof( unsigned int ); + } + + pos += num_uints; +} + +/** + * This template function reads data of type T from a given position of a + * std::vector< unsigned int >. The function is used to read SecondaryEvents + * data from the NEST communication buffer. The pos iterator is advanced + * during execution. For a discussion on the functionality of this function see + * github issue #181 and pull request #184. + */ +template < typename T > +void +read_from_comm_buffer( T& d, std::vector< unsigned int >::iterator& pos ) +{ + // there is no aliasing problem here, since cast to char* invalidate strict + // aliasing assumptions + char* const c = reinterpret_cast< char* >( &d ); + + const size_t num_uints = number_of_uints_covered< T >(); + size_t left_to_copy = sizeof( T ); + + for ( size_t i = 0; i < num_uints; i++ ) + { + memcpy( c + i * sizeof( unsigned int ), &( *( pos + i ) ), std::min( left_to_copy, sizeof( unsigned int ) ) ); + left_to_copy -= sizeof( unsigned int ); + } + + pos += num_uints; +} + +/** + * Template class for the storage and communication of a std::vector of type + * DataType. The class provides the functionality to communicate homogeneous + * data of type DataType. The second template type Subclass (which should be + * chosen as the derived class itself) is used to distinguish derived classes + * with the same DataType. This is required because of the included static + * variables in the base class (as otherwise all derived classes with the same + * DataType would share the same static variables). + * + * Technically the DataSecondaryEvent only contains iterators pointing to + * the memory location of the std::vector< DataType >. + * + * Conceptually, there is a one-to-one mapping between a SecondaryEvent + * and a SecondaryConnectorModel. The synindex of this particular + * SecondaryConnectorModel is stored as first element in the static vector + * supported_syn_ids_ on model registration. There are however reasons (e.g. + * the usage of CopyModel or the creation of the labeled synapse model + * duplicates for pyNN) which make it necessary to register several + * SecondaryConnectorModels with one SecondaryEvent. Therefore the synindices + * of all these models are added to supported_syn_ids_. The + * supports_syn_id()-function allows testing if a particular synid is mapped + * with the SecondaryEvent in question. + */ +template < typename DataType, typename Subclass > +class DataSecondaryEvent : public SecondaryEvent +{ +private: + // we chose std::vector over std::set because we expect this to be short + static std::vector< synindex > pristine_supported_syn_ids_; + static std::vector< synindex > supported_syn_ids_; + static size_t coeff_length_; // length of coeffarray + + union CoeffarrayBegin { + std::vector< unsigned int >::iterator as_uint; + typename std::vector< DataType >::iterator as_d; + + CoeffarrayBegin() {}; // need to provide default constructor due to + // non-trivial constructors of iterators + } coeffarray_begin_; + + union CoeffarrayEnd { + std::vector< unsigned int >::iterator as_uint; + typename std::vector< DataType >::iterator as_d; + + CoeffarrayEnd() {}; // need to provide default constructor due to + // non-trivial constructors of iterators + } coeffarray_end_; + +public: + /** + * This function is needed to set the synid on model registration. + * At this point no object of this type is available and the + * add_syn_id-function cannot be used as it is virtual in the base class + * and therefore cannot be declared as static. + */ + static void + set_syn_id( const synindex synid ) + { + VPManager::assert_single_threaded(); + pristine_supported_syn_ids_.push_back( synid ); + supported_syn_ids_.push_back( synid ); + } + + /** + * This function is needed to add additional synids when the + * corresponded connector model is copied. + * This function needs to be a virtual function of the base class as + * it is called from a pointer on SecondaryEvent. + */ + void + add_syn_id( const synindex synid ) + { + assert( not supports_syn_id( synid ) ); + VPManager::assert_single_threaded(); + supported_syn_ids_.push_back( synid ); + } + + const std::vector< synindex >& + get_supported_syn_ids() const + { + return supported_syn_ids_; + } + + /** + * Resets the vector of supported syn ids to those originally + * registered via ModelsModule or user defined Modules, i.e., + * removes all syn ids created by CopyModel. This is important to + * maintain consistency across ResetKernel, which removes all copied + * models. + */ + void + reset_supported_syn_ids() + { + supported_syn_ids_.clear(); + for ( size_t i = 0; i < pristine_supported_syn_ids_.size(); ++i ) + { + supported_syn_ids_.push_back( pristine_supported_syn_ids_[ i ] ); + } + } + + static void + set_coeff_length( const size_t coeff_length ) + { + VPManager::assert_single_threaded(); + coeff_length_ = coeff_length; + } + + bool + supports_syn_id( const synindex synid ) const + { + return ( std::find( supported_syn_ids_.begin(), supported_syn_ids_.end(), synid ) != supported_syn_ids_.end() ); + } + + void + set_coeffarray( std::vector< DataType >& ca ) + { + coeffarray_begin_.as_d = ca.begin(); + coeffarray_end_.as_d = ca.end(); + assert( coeff_length_ == ca.size() ); + } + + /** + * The following operator is used to read the information of the + * DataSecondaryEvent from the buffer in EventDeliveryManager::deliver_events + */ + std::vector< unsigned int >::iterator& + operator<<( std::vector< unsigned int >::iterator& pos ) + { + // The synid can be skipped here as it is stored in a static vector + + // generating a copy of the coeffarray is too time consuming + // therefore we save an iterator to the beginning+end of the coeffarray + coeffarray_begin_.as_uint = pos; + + pos += coeff_length_ * number_of_uints_covered< DataType >(); + + coeffarray_end_.as_uint = pos; + + return pos; + } + + /** + * The following operator is used to write the information of the + * DataSecondaryEvent into the secondary_events_buffer_. + * All DataSecondaryEvents are identified by the synid of the + * first element in supported_syn_ids_. + */ + std::vector< unsigned int >::iterator& + operator>>( std::vector< unsigned int >::iterator& pos ) + { + for ( typename std::vector< DataType >::iterator it = coeffarray_begin_.as_d; it != coeffarray_end_.as_d; ++it ) + { + // we need the static_cast here as the size of a stand-alone variable + // and a std::vector entry may differ (e.g. for std::vector< bool >) + write_to_comm_buffer( static_cast< DataType >( *it ), pos ); + } + return pos; + } + + size_t + size() + { + size_t s = number_of_uints_covered< synindex >(); + s += number_of_uints_covered< index >(); + s += number_of_uints_covered< DataType >() * coeff_length_; + + return s; + } + + const std::vector< unsigned int >::iterator& + begin() + { + return coeffarray_begin_.as_uint; + } + + const std::vector< unsigned int >::iterator& + end() + { + return coeffarray_end_.as_uint; + } + + DataType get_coeffvalue( std::vector< unsigned int >::iterator& pos ); +}; + +/** + * Event for gap-junction information. The event transmits the interpolation + * of the membrane potential to the connected neurons. + */ +class GapJunctionEvent : public DataSecondaryEvent< double, GapJunctionEvent > +{ + +public: + GapJunctionEvent() + { + } + + void operator()(); + GapJunctionEvent* clone() const; +}; + +/** + * Event for rate model connections without delay. The event transmits + * the rate to the connected neurons. + */ +class InstantaneousRateConnectionEvent : public DataSecondaryEvent< double, InstantaneousRateConnectionEvent > +{ + +public: + InstantaneousRateConnectionEvent() + { + } + + void operator()(); + InstantaneousRateConnectionEvent* clone() const; +}; + +/** + * Event for rate model connections with delay. The event transmits + * the rate to the connected neurons. + */ +class DelayedRateConnectionEvent : public DataSecondaryEvent< double, DelayedRateConnectionEvent > +{ + +public: + DelayedRateConnectionEvent() + { + } + + void operator()(); + DelayedRateConnectionEvent* clone() const; +}; + +/** + * Event for diffusion connections (rate model connections for the + * siegert_neuron). The event transmits the rate to the connected neurons. + */ +class DiffusionConnectionEvent : public DataSecondaryEvent< double, DiffusionConnectionEvent > +{ +private: + // drift factor of the corresponding connection + weight drift_factor_; + // diffusion factor of the corresponding connection + weight diffusion_factor_; + +public: + DiffusionConnectionEvent() + { + } + + void operator()(); + DiffusionConnectionEvent* clone() const; + + void + set_diffusion_factor( weight t ) + { + diffusion_factor_ = t; + }; + + void + set_drift_factor( weight t ) + { + drift_factor_ = t; + }; + + weight get_drift_factor() const; + weight get_diffusion_factor() const; +}; + +template < typename DataType, typename Subclass > +inline DataType +DataSecondaryEvent< DataType, Subclass >::get_coeffvalue( std::vector< unsigned int >::iterator& pos ) +{ + DataType elem; + read_from_comm_buffer( elem, pos ); + return elem; +} + +template < typename Datatype, typename Subclass > +std::vector< synindex > DataSecondaryEvent< Datatype, Subclass >::pristine_supported_syn_ids_; + +template < typename DataType, typename Subclass > +std::vector< synindex > DataSecondaryEvent< DataType, Subclass >::supported_syn_ids_; + +template < typename DataType, typename Subclass > +size_t DataSecondaryEvent< DataType, Subclass >::coeff_length_ = 0; + +inline GapJunctionEvent* +GapJunctionEvent::clone() const +{ + return new GapJunctionEvent( *this ); +} + +inline InstantaneousRateConnectionEvent* +InstantaneousRateConnectionEvent::clone() const +{ + return new InstantaneousRateConnectionEvent( *this ); +} + +inline DelayedRateConnectionEvent* +DelayedRateConnectionEvent::clone() const +{ + return new DelayedRateConnectionEvent( *this ); +} + +inline DiffusionConnectionEvent* +DiffusionConnectionEvent::clone() const +{ + return new DiffusionConnectionEvent( *this ); +} + +inline weight +DiffusionConnectionEvent::get_drift_factor() const +{ + return drift_factor_; +} + +inline weight +DiffusionConnectionEvent::get_diffusion_factor() const +{ + return diffusion_factor_; +} + +} // namespace nest + +#endif /* #ifndef SECONDARY_EVENT_H */ From f8e95e5d657d3cfd0234f3eeb56e72199c5597e4 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Thu, 17 Feb 2022 18:18:56 +0100 Subject: [PATCH 003/150] Remove unused data structure for secondary connector models --- nestkernel/model_manager.h | 1 - nestkernel/model_manager_impl.h | 22 ---------------------- 2 files changed, 23 deletions(-) diff --git a/nestkernel/model_manager.h b/nestkernel/model_manager.h index 8295308768..74b2603aee 100644 --- a/nestkernel/model_manager.h +++ b/nestkernel/model_manager.h @@ -273,7 +273,6 @@ class ModelManager : public ManagerInterface */ std::vector< std::vector< ConnectorModel* > > connection_models_; - std::vector< ConnectorModel* > secondary_connector_models_; std::vector< std::map< synindex, SecondaryEvent* > > secondary_events_prototypes_; DictionaryDatum modeldict_; //!< Dictionary of all node models diff --git a/nestkernel/model_manager_impl.h b/nestkernel/model_manager_impl.h index fd6bf04bf7..ae7361f4a8 100644 --- a/nestkernel/model_manager_impl.h +++ b/nestkernel/model_manager_impl.h @@ -109,17 +109,6 @@ ModelManager::register_secondary_connection_model( const std::string& name, cons enumFlagSet( flags, RegisterConnectionModelFlags::SUPPORTS_WFR ) ); synindex syn_id = register_connection_model_( cm ); - - // idea: save *cm in data structure - // otherwise when number of threads is increased no way to get further - // elements - if ( secondary_connector_models_.size() < syn_id + ( unsigned int ) 1 ) - { - secondary_connector_models_.resize( syn_id + 1, NULL ); - } - - secondary_connector_models_[ syn_id ] = cm; - ConnectionT< TargetIdentifierPtrRport >::EventType::set_syn_id( syn_id ); // create labeled secondary event connection model @@ -129,17 +118,6 @@ ModelManager::register_secondary_connection_model( const std::string& name, cons enumFlagSet( flags, RegisterConnectionModelFlags::SUPPORTS_WFR ) ); syn_id = register_connection_model_( cm ); - - // idea: save *cm in data structure - // otherwise when number of threads is increased no way to get further - // elements - if ( secondary_connector_models_.size() < syn_id + ( unsigned int ) 1 ) - { - secondary_connector_models_.resize( syn_id + 1, NULL ); - } - - secondary_connector_models_[ syn_id ] = cm; - ConnectionT< TargetIdentifierPtrRport >::EventType::set_syn_id( syn_id ); } From 64be25064d30b97588f1c0b262833020d8491f00 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Thu, 17 Feb 2022 18:20:30 +0100 Subject: [PATCH 004/150] Unbreak short lines --- nestkernel/model_manager.cpp | 10 ++++------ nestkernel/model_manager_impl.h | 6 ++---- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index c6ae101506..41c26a9d85 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -266,10 +266,9 @@ ModelManager::copy_connection_model_( index old_id, Name new_name ) if ( new_id == invalid_synindex ) // we wrapped around (=63), maximal id of // connection_model = 62, see nest_types.h { - const std::string msg = - "CopyModel cannot generate another synapse. Maximal synapse model count " - "of " - + std::to_string( MAX_SYN_ID ) + " exceeded."; + const std::string msg = String::compose( + "CopyModel cannot generate another synapse. Maximal synapse model count of %1 exceeded.", + MAX_SYN_ID ); LOG( M_ERROR, "ModelManager::copy_connection_model_", msg ); throw KernelException( "Synapse model count exceeded" ); } @@ -572,8 +571,7 @@ ModelManager::register_connection_model_( ConnectorModel* cf ) { delete cf; std::string msg = String::compose( - "A synapse type called '%1' already exists.\n" - "Please choose a different name!", + "A synapse type called '%1' already exists. Please choose a different name!", cf->get_name() ); throw NamingConflict( msg ); } diff --git a/nestkernel/model_manager_impl.h b/nestkernel/model_manager_impl.h index ae7361f4a8..9285e8a95c 100644 --- a/nestkernel/model_manager_impl.h +++ b/nestkernel/model_manager_impl.h @@ -67,8 +67,7 @@ ModelManager::register_connection_model( const std::string& name, const Register enumFlagSet( flags, RegisterConnectionModelFlags::REQUIRES_URBANCZIK_ARCHIVING ) ); register_connection_model_( cf ); - // register the "hpc" version with the same parameters but a different target - // identifier + // register the "hpc" version with the same parameters but a different target identifier if ( enumFlagSet( flags, RegisterConnectionModelFlags::REGISTER_HPC ) ) { cf = new GenericConnectorModel< ConnectionT< TargetIdentifierIndex > >( name + "_hpc", @@ -81,8 +80,7 @@ ModelManager::register_connection_model( const std::string& name, const Register register_connection_model_( cf ); } - // register the "lbl" (labeled) version with the same parameters but a - // different connection type + // register the "lbl" (labeled) version with the same parameters but a different connection type if ( enumFlagSet( flags, RegisterConnectionModelFlags::REGISTER_LBL ) ) { cf = new GenericConnectorModel< ConnectionLabel< ConnectionT< TargetIdentifierPtrRport > > >( name + "_lbl", From 78f1f521aead7bf7d3c3a941601e29fd012dd747 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 22 Apr 2022 14:59:04 +0200 Subject: [PATCH 005/150] Prohibit recording from noise_generator in multithreaded mode. --- models/noise_generator.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/models/noise_generator.h b/models/noise_generator.h index 00af5a03f7..328f1eb1f3 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -307,6 +307,11 @@ class noise_generator : public StimulationDevice inline port noise_generator::handles_test_event( DataLoggingRequest& dlr, rport receptor_type ) { + if ( kernel().vp_manager.get_num_threads() > 1 ) + { + throw KernelException( "Recording from a noise_generator is only possible in single-threaded mode." ); + } + if ( receptor_type != 0 ) { throw UnknownReceptorType( receptor_type, get_name() ); From 4cffaa158efc3ea9598d48c1d20080f8a0edc0e2 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 22 Apr 2022 15:37:23 +0200 Subject: [PATCH 006/150] Add regression test for #2282. --- testsuite/regressiontests/issue-2282.sli | 71 ++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 testsuite/regressiontests/issue-2282.sli diff --git a/testsuite/regressiontests/issue-2282.sli b/testsuite/regressiontests/issue-2282.sli new file mode 100644 index 0000000000..7e5955c561 --- /dev/null +++ b/testsuite/regressiontests/issue-2282.sli @@ -0,0 +1,71 @@ +/* + * issue-2282.sli + * + * 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 . + * + */ + +/** @BeginDocumentation + +Name: testsuite::issue-2282 Ensure multimeter-recording from noise_generator prohibited in if multithreaded + +Synopsis: (issue-2282) run -> NEST exits if test fails + +Description: +This ticket ensures that the multimeter cannot be connected to a noise_generator if +NEST runs with multiple threads. + +Author: Hans Ekkehard Plesser +*/ + +(unittest) run +/unittest using + +skip_if_not_threaded + +M_ERROR setverbosity + +/test_sim +{ + /N 3 def + /neurons /iaf_psc_alpha N Create def + /noise /noise_generator N << /mean 1000.0 /std 1.0 /dt 0.1 >> Create def + /mm /multimeter << /record_from [ /I ] /interval 0.1 >> Create def + + noise neurons /one_to_one << /delay 0.1 >> Connect + mm noise Connect + + 2.0 Simulate +} +def + +% Test all works in single-threaded mode (should get only non-zero values) +{ + << /local_num_threads 1 >> SetKernelStatus + test_sim + mm GetStatus 0 get /events get /I get + true exch { 0 gt and } Fold +} +assert_or_die + +% Test that an error is emitted in multi-threaded mode +{ + << /local_num_threads 2 >> SetKernelStatus + test_sim +} +fail_or_die From c10e47f263ca1619db1d84492c46f54e1a498366 Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 24 Apr 2022 14:10:22 +0200 Subject: [PATCH 007/150] Fix copied model id --- nestkernel/model_manager.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 041de0d811..508a0d6b19 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -250,12 +250,18 @@ ModelManager::copy_node_model_( index old_id, Name new_name ) node_models_.push_back( new_model ); index new_id = node_models_.size() - 1; + new_model->set_model_id( new_id ); + modeldict_->insert( new_name, new_id ); #pragma omp parallel { const thread t = kernel().vp_manager.get_thread_id(); const int model_id = new_model->get_model_id(); + + assert(model_id > 0); + assert(model_id > old_id); + proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); } From dc0c1e6822c78954f3b92007b1366b6576319617 Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 24 Apr 2022 14:34:53 +0200 Subject: [PATCH 008/150] Compare int wit nest::index --- nestkernel/model_manager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 508a0d6b19..7f1c496ad2 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -258,9 +258,9 @@ ModelManager::copy_node_model_( index old_id, Name new_name ) { const thread t = kernel().vp_manager.get_thread_id(); const int model_id = new_model->get_model_id(); - + assert(model_id > 0); - assert(model_id > old_id); + assert(((index)model_id) > old_id); proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); } From be1f31afa0e3669c42239a34178b9a3f2923788e Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 24 Apr 2022 14:42:10 +0200 Subject: [PATCH 009/150] add spaces --- nestkernel/model_manager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 7f1c496ad2..63145a5187 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -259,8 +259,8 @@ ModelManager::copy_node_model_( index old_id, Name new_name ) const thread t = kernel().vp_manager.get_thread_id(); const int model_id = new_model->get_model_id(); - assert(model_id > 0); - assert(((index)model_id) > old_id); + assert( model_id > 0 ); + assert( ( ( index ) model_id ) > old_id ); proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); } From 522ec7cd4e66c7d826e7ada63025c3df933dc13a Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Mon, 25 Apr 2022 09:39:33 +0200 Subject: [PATCH 010/150] Fixed typo. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Håkon Bakke Mørk --- testsuite/regressiontests/issue-2282.sli | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testsuite/regressiontests/issue-2282.sli b/testsuite/regressiontests/issue-2282.sli index 7e5955c561..05ffa54f8e 100644 --- a/testsuite/regressiontests/issue-2282.sli +++ b/testsuite/regressiontests/issue-2282.sli @@ -22,7 +22,7 @@ /** @BeginDocumentation -Name: testsuite::issue-2282 Ensure multimeter-recording from noise_generator prohibited in if multithreaded +Name: testsuite::issue-2282 Ensure multimeter-recording from noise_generator is prohibited if multithreaded Synopsis: (issue-2282) run -> NEST exits if test fails From 4dfc86de5e3683e93a44be2041c99d261853d46d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Mon, 23 May 2022 14:32:34 +0200 Subject: [PATCH 011/150] Added conversion from IntegerDatum to ConstantParameter --- nestkernel/nestmodule.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index a47b8cc186..620d5805f8 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -125,6 +125,13 @@ NestModule::create_parameter( const Token& t ) return new ConstantParameter( *dd ); } + // If t is a IntegerDatum, create a ConstantParameter with this value + IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); + if ( id ) + { + return new ConstantParameter( static_cast< double >( *id ) ); + } + DictionaryDatum* dictd = dynamic_cast< DictionaryDatum* >( t.datum() ); if ( dictd ) { From 2b0cae0750f1b2a055fd02de94ecf64b865ad7c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Mon, 23 May 2022 14:32:53 +0200 Subject: [PATCH 012/150] Added test of connecting layers with integer parameter values --- .../test_spatial/test_connect_layers.py | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/testsuite/pytests/test_spatial/test_connect_layers.py b/testsuite/pytests/test_spatial/test_connect_layers.py index 139875481f..68d35652fb 100644 --- a/testsuite/pytests/test_spatial/test_connect_layers.py +++ b/testsuite/pytests/test_spatial/test_connect_layers.py @@ -452,6 +452,27 @@ def test_connect_receptor_type(self): conns = nest.GetConnections() self.assertEqual(conns.get('receptor'), [receptor_type]*len(multisyn_layer)*indegree) + def test_connect_integer_param(self): + # weight and delay are intentionally integers for this test. + weight = 2 + delay = 2 + multisyn_layer = nest.Create( + 'iaf_psc_exp', + positions=nest.spatial.grid(self.dim, extent=self.extent)) + indegree = 10 + # Combination of fixed_indegree and connection probability (kernel) to trigger ConnectLayers. + conn_spec = { + 'rule': 'fixed_indegree', + 'indegree': indegree, + 'p': 1.0 + } + syn_spec = {'weight': weight, 'delay': delay} + + nest.Connect(multisyn_layer, multisyn_layer, conn_spec, syn_spec) + conns = nest.GetConnections() + self.assertEqual(conns.weight, [weight] * len(multisyn_layer) * indegree) + self.assertEqual(conns.delay, [delay] * len(multisyn_layer) * indegree) + def suite(): suite = unittest.makeSuite(ConnectLayersTestCase, 'test') From 00e9051e12f6f38073a7dea4066425e9b6e24ebe Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 8 Jun 2022 11:37:09 +0200 Subject: [PATCH 013/150] Improvements to noise generator documentation. --- .../model_details/noise_generator.ipynb | 89 ++++++++++--------- models/noise_generator.h | 42 ++++----- 2 files changed, 70 insertions(+), 61 deletions(-) diff --git a/doc/htmldoc/neurons/model_details/noise_generator.ipynb b/doc/htmldoc/neurons/model_details/noise_generator.ipynb index 65c9f589f7..c288293b57 100644 --- a/doc/htmldoc/neurons/model_details/noise_generator.ipynb +++ b/doc/htmldoc/neurons/model_details/noise_generator.ipynb @@ -6,11 +6,14 @@ "source": [ "# The NEST `noise_generator`\n", "\n", - "#### Hans Ekkehard Plesser, 2015-06-25\n", + "#### Hans Ekkehard Plesser, 2015-06-25, 2022-05-23\n", "\n", "This notebook describes how the NEST `noise_generator` model works and what effect it has on model neurons.\n", "\n", - "NEST needs to be in your `PYTHONPATH` to run this notebook.\n", + "To excute code examples in this notebook, the following packages need to be available\n", + "- `nest`\n", + "- `sympy`\n", + "- `statsmodels`\n", "\n", "## Basics\n", "\n", @@ -62,8 +65,7 @@ "$$\\langle (I_j-\\mu) (I_k-\\mu)\\rangle = \\sigma^2\\delta_{jk}$$\n", "where $\\delta_{jk}$ is Kronecker's delta.\n", "1. With modulation, the autocorrlation is\n", - "$$\\langle (I_j-\\mu) (I_k-\\mu)\\rangle = \\sigma_j^2\\delta_{jk}\\qquad\\text{where}\\; \\sigma_j = \\sqrt{\\sigma^2 + \\sigma_m^2\\sin( j\\delta\\omega + \\phi_d)}\\;.$$\n", - "Note that it is currently not possible to record this noise current directly in NEST, since a `multimeter` cannot record from a `noise_generator`." + "$$\\langle (I_j-\\mu) (I_k-\\mu)\\rangle = \\sigma_j^2\\delta_{jk}\\qquad\\text{where}\\; \\sigma_j = \\sqrt{\\sigma^2 + \\sigma_m^2\\sin( j\\delta\\omega + \\phi_d)}\\;.$$" ] }, { @@ -80,7 +82,7 @@ "\n", "$$\\dot{V} = - \\frac{V}{\\tau} + \\frac{I}{C}$$\n", "\n", - "where $\\tau$ is the membrane time constant and $C$ the capacitance. We further assume $V(0)=0$ mV. We now focus on the membrane potential at times $t_j=j\\delta$. Let $V_j=V(j\\delta)$ be the membrane potential at time $t_j$. Then, a constant currant $I_j$ will be applied to the neuron until $t_{j+1}=t_j+\\delta$, at which time the membrane potential will be\n", + "where $\\tau$ is the membrane time constant and $C$ the capacitance. We further assume $V(0)=0$ mV. We now focus on the membrane potential at times $t_j=j\\delta$. Let $V_j=V(j\\delta)$ be the membrane potential at time $t_j$. Then, a constant current $I_j$ will be applied to the neuron until $t_{j+1}=t_j+\\delta$, at which time the membrane potential will be\n", "\n", "$$V_{j+1} = V_j e^{-\\delta/\\tau} + \\left(1-e^{-\\delta/\\tau}\\right)\\frac{I_j\\tau}{C} \\;.$$\n", "\n", @@ -128,7 +130,7 @@ " &= \\langle V_{j+1}\\rangle^2 + \\alpha \\sum_{k=0}^{j} \\sigma_k^2 q^{2k} \\;.\n", "\\end{align}\n", "\n", - "Evaluating the remaining sum for the modulate case will be tedious, so we focus for now on the unmodulated case, i.e., $\\sigma\\equiv\\sigma_k$, so that we again are left with a geometric sum, this time over $q^2$. We can now subtract the square of the mean to obtain the variance\n", + "Evaluating the remaining sum for the modulated case will be tedious, so we focus for now on the unmodulated case, i.e., $\\sigma\\equiv\\sigma_k$, so that we again are left with a geometric sum, this time over $q^2$. We can now subtract the square of the mean to obtain the variance\n", "\n", "\\begin{align}\n", "\\langle (\\Delta V_{j+1})^2 \\rangle &= \\langle V_{j+1}^2 \\rangle - \\langle V_{j+1}\\rangle^2 \\\\\n", @@ -152,12 +154,12 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/latex": [ "$\\displaystyle \\frac{x}{2} - \\frac{x^{3}}{24} + \\frac{x^{5}}{240} + O\\left(x^{6}\\right)$" ], @@ -168,7 +170,7 @@ "2 24 240 " ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -219,20 +221,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import math\n", "import numpy as np\n", "import scipy\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -244,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -259,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -272,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -285,12 +286,20 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "import nest\n", - "\n", + "nest.set_verbosity('M_ERROR')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ "def simulate(mu, sigma, dt=1.0, tau_m=10., C_m=250., N=1000, t_max=50.):\n", " '''\n", " Simulate an ensemble of N iaf_psc_alpha neurons driven by noise_generator.\n", @@ -339,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -351,7 +360,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -400,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -412,7 +421,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEKCAYAAAA4t9PUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABKsklEQVR4nO3dd3hUZfbA8e8JXUR6hwislLCAiBE7TVcpStBFRVGxLKwuirp2f/bV1XXXVXRRRGVtNEUBEQQsVFmkS0cCglRBQDqBJOf3x5lJJiSBGVIm5Xye5z4zc9u8cwP33LeLquKcc86drJhoJ8A551zh5oHEOedcjnggcc45lyMeSJxzzuWIBxLnnHM54oHEOedcjpSMdgLyUrVq1bRBgwbRToZzzhUaCxYs+FVVq0dyTJEOJA0aNGD+/PnRToZzzhUaIrIh0mO8aMs551yOeCBxzjmXIx5InHPO5YgHEueccznigcQ551yOeCBxzjmXI0W6+a9zzuW33bth1SrYvx+aNIH69SGmiD+y51sgEZH6wAdALSAVGKKqA4/ZR4CBQFfgIHCLqi4MbOsc2FYCeEdVX8yvtDvniq6kJPj4Y/j5Z2jTBuLjofoJuuOpwqZNsHKlBY2VK9Pf//JLxn3LlYOmTSEuDpo1s6V5c1uKSoDJzxxJMnC/qi4UkQrAAhH5SlVXhOzTBWgcWM4F3gTOFZESwCDgD8AmYJ6IfH7Msc65KDp6FDZuhLJl4ZRTbClVCkSinbKsbdsGgwfDm2/C9u0Zt8XGWkCJj7fgcuBAxmCxapWtC6pUyQJFt27pAePUU+HHH9P3nzMHRo60IARQs6btf8UVcOmlUKFCvv30XJdvgURVtwJbA+/3ichKoC4QGgwSgA/Upm2cIyKVRKQ20ABIVNV1ACIyMrCvBxLnomz5cvjvf+HDDzPfkGNi0oNK+fJQrx40bAiNGtkSfF+rVv49nS9cCAMH2k39yBG7md9zD7RtC4sWwfz5sGCBvX72WcZjY2MtSPzpT/YaDBo1amQdMDt0yPj50CELLj/8ABMnwqefwtChULq07Xv55ZaDOXQo8yJi1+t3v7OlUSMLVgVBVOpIRKQBcBbw/TGb6gIbQz5vCqzLav252Zy7H9APIDY2NncS7JzL4Lff7Eb83//C3LlQsiR07w5dukBKit34Dh60Jfh+3z4rPvr2Wws6obN8lywJVapA1ar2Gs77qlXDu5Hu3w8zZ8I338BXX8GSJRbU+vWDu++2eoygDh0y3vx377ab/mmn2X45vXGXKwdnnmnLzTdbLu677+CLL2y5//6M+8fE2DHlykFysl33UDVrWlCpUMGu8+HDmV9TUqBixYzLqafC9dfDlVfab5w1y4LqkSMn97vyPZCIyKnAp8C9qrr32M1ZHKLHWZ95peoQYAhAfHy8T0jvXA6kpMCWLbBhA6xfb69Ll8K4cXaTatkSXnkFevc+cb1CqKQkO9e6dfDTT1YktnMn7Nply8aNsHixvQ8tQjpWrVrQooUtLVvaa5Mmlkv6+msLHv/7n92ES5eGCy+09N5yixVHnUjlyplzFScjKcmC6YED6QG2YkXLYbRrZ9e4aVMrbjt0yK77RRdZsdfBg9C/v13vffssmPz2m+WGKlWCFStg2jQLzKqQmmrLOefA2WdboBg5MnOaYmIskPz4oz0E5ES+BhIRKYUFkWGq+lkWu2wC6od8rgdsAUpns945lwtU7ca+eHH6snSp5SCSkzPuW7s23HabLW3anFwdSJkydsMPzQ1kJykpPcDs2pUecHbssLqHZcvgrbfsBhxKxG6k998Pl1xiQeSUU078fSkpdsM+ejQ9OM6cacV2e/fasm+ftcbq08e233yzVb4Hg8SBA9C5MwwaZNurVbOcUag//QneftvSeeONGXNowXRceaVtnzrV6p6CS9WqFmRuucWCyoABtr5MmfR9unSBCy6w7Z062bbSpdOXVq3se1q0sGK80qWtTisu7sTX6Fiix6Y+jwRaZL0P7FLVe7PZpxtwF9Zq61zgNVVtKyIlgR+BS4DNwDzgBlVdfrzvjI+PVx/917nMVO0pdty49MCxZ49tE7Gn41atrNikQQM4/XRbYmPDuxnnt5QUy9ksW2YV4rGx0Lo1/P73tn3GDFizxp7Od+2y10qV4IUXbPu111rxzt696Tmg88+H2bPtfcuWdu5QnTvDl1/a++7d7Zyh9UEXXAB/+Yttf+UVu67BbaecYtc2eDNfs8aKr8qXTw8I0WrRJSILVDU+kmPyM0dyIXATsFREFgfWPQbEAqjqYGAiFkQSsea/twa2JYvIXcBkrPnv0BMFEedcZqpWT/Dss1Y2f8opdjO7/nq78bZubU+o5ctHO6UZ/fqrFXdt3245kR077Kb/1FO2/cknYfRoCxK//Wa5qJo1ragI4OWX4fPP7X2JElZk1bJl+vnPPNMCS4UKVh9SoYIFzqBhwywQBLdVqGBP70HBc2fnvvuOv71x43CuQsGVbzmSaPAciXNGFSZNsgAyZ461nnrkEbj9dnsCzm+pqRYMqlWzG/ucOTBlitUVbN2aHjCWLrUn9XvvtZZWoUqXttxDyZLw+uuWo6hSxYJElSpWLBUsetq40a5B5cpW0VxQmyQXBAU9R+Kcy2d79lhF61tvWdPW2FjrO3HLLVZ8kheOHIHNm63OpU0be4r/5ht47bX0QLFtmxVHrV1rzVhnzbLcRfXqVgdTo4atT0qyQNKnD7Rvb9tr1LDXSpXSA8Ldd9uSnfr1s9/mcs4DiXNFjKpVDr/7LnzyiVVCt2gBQ4bYDbl06Zyd/8ABa221YQOcdRbUrWsto+6/39Zt3ZpecTx1qrV62r/f6jDq1LG01KljS8WKtl///lZhnF3azjrLFlcweSBxrojYuhXef986uK1ZY+X4N91kxVfnnBNZcc5vv1luoXp1y8X8+KOdJzExvd4BrD/IjTemtxS67DLbP1g537q17ZeQYEt2ypU7mV/sCgoPJM4VcCkp1mJo9mx74j98OONy6JDd+L/7zva9+GL4v/+Dnj2PX2mekmJNVStUsCKwAQMsYCQmWuU2wPPPw2OPWfFUTAx07QpnnGHFTqefnt5U9KyzrKOhK548kDhXwBw+bJXP06ZZ8Jgzx/otgBX9lCuXngMIvi9XDh54wPp2ZNc3Y/Ro66i3cqV1YvvxR9v/jTcs4MycaU19r77agsUZZ1g/DLCOf9On58evd4WRBxLnoiw52cZ2+uYbe6r/7jsLJjEx1kT1ppusT8IFF9iN/nhFVHv2WEBYvNiG9qhSBV56ybY98IB1MGzY0HISl19uHdXAWj6tW5fXv9QVVR5InIuCLVusOe6XX1q/jmBnwFat4I477Abfrl16ZXRWdu+2XMW5gVHneva0QQCDqlWzoqigb7+1nEVB7FDoCjcPJM7lg6NHrZjqyy9tWbLE1tepA3/8o1VSd+xoTVuzs3KlBZ25c20J9obeu9dyFF26WHPb1q2tg12dOhlzL40a5elPdMWYBxLn8si2bTai68SJNoDgvn12w7/oInjxRbvxt2yZdVHV9u1WRDVzJjzzjOVMRo+2Hty1a1su5NZbbejzoNtvz7/f5lwo79nuXC5aswbGjrXlf/+z/hT161vQ6NzZBg887bSsj121Cv71LwseP/5o68qVs74Y555rM+8lJ1u/Defyivdsdy6fqVpFeTB4LA+MANemjeUkEhKyznVs3Wq5lK+/trqNK6+0CvZPP7Ucy+23Wx1JmzbpnfRq1szPX+Zc+DyQOHeSli2z0V1nzrTxotq1s8mSEhIyDvgXlJRk41t9/XX6SLJVq1rgAKvX2Lmz6Mzj7YoPDyTORejwYfjb36xZbcWK8J//QK9eFhRCJSbC+PFWHPXgg5azmDTJBky86Sabp7t16/TAIeKDCbrCyQOJcxGYOhX+/GerC7nlFqvTCA0g8+bBxx9bAFm92tZ16GCBRMSKvjzH4Yoa/yftXBh27bJ6i06dbAj0r7+2+cpPOcXmokhNtf0++siGO4+NtdFu162z4BPkQcQVRfk5Q+JQ4Apgu6q2yGL7g0DvwMeSQBxQXVV3ich6YB+QAiSH26LAW225nNi/33qbT5wIn31mHQAfeAAeesiGC/nkE8t57N9vM/BdfLG1rCpXLvuWWc4VdAW91dZ7wH+AD7LaqKr/BP4JICJXAvep6q6QXTqq6q95nUhXvCUmwoQJFjymTbO5NSpUsA6Djz9uxVOnn27Bo2pVm1nwmmvgvPPseG9Z5YqjfAskqjpDRBqEufv1wIg8TI5zGXz7reU2Fi2yz82awV132bzaS5faa+vW1kP91lttju4OHayDoXPF3Qn/G4hIlTDOk6qqv+U8OSAipwCdgbtCViswRUQUeEtVhxzn+H5AP4DY2NjcSJIrwtatswAyZowNiPjaazYk+syZ8MEH1kmwTBlr5gs2T/drr0U1yc4VOOE8T20JLMdrmFgCyK279pXAd8cUa12oqltEpAbwlYisUtUZWR0cCDJDwOpIcilNrojZtw/+/nf4978tOPztbxZQypaFa6+1+o+LL7ZZ/3r2tGldnXNZCyeQrFTV405yKSKLcik9AL04plhLVbcEXreLyBigLZBlIHHueFJS4L33rL5j2zabeyM2Ft580wJIkybw7LM2FpYPcuhceMIJJOfn0j4nJCIVgfbAjSHrygMxqrov8P4y4Nnc+D5XvHz1leU6liyxOpDf/c6GNVG1sbCSkmy/Zs2imkznCp1wWrX/S0QuPN4Oqnr4RCcRkRHA/4CmIrJJRG4XkTtE5I6Q3a4CpqjqgZB1NYFZIvIDMBeYoKqTwki3cwDMn2+9yC+7zIq03nkH1q+3FlqPPmr1JBMm2JhYzrnIhZMjWYMFk9rAKGCEqi6O9ItU9fow9nkPayYcum4dcGak3+fcmjU2d/knn1jfjt//3gZYLFMGmje3aWSDAyI6507eCXMkqjpQVc/Hipx2Af8VkZUi8qSIZDM7tHPRs2MH3HmnFVGNGWMDKh4+bEVZycm2z/nnexBxLreEPWCDqm5Q1X8EKt5vwIqhVuZZypyLUGoqDBkCTZvaq6oFkT//2ca9GjcOypePdiqdK3rCDiQiUkpErhSRYcCXwI/AH/MsZc5FYOFCm+/8z3+24djnzYPHHrO6kEGDoHHjaKfQuaIrnA6Jf8B6mnfDKrtHAv2OqRB3Lip++w3694fhw+1zgwbWS13EJoVyzuW9cHIkj2GtreJU9UpVHeZBxEXb3r3WWbBGDQsipUtbDmTRIp/Tw7n8dsIciap2zI+EOBeOffvg9dfh5ZdtaPeYGJsX5OWXoUo4g/k453Jd2EPOiUg88H/A6YHjBFBVbZVHaXMuzf798Mor8MILcOgQdOsGTz5pvdJr1Yp26pwr3iIZu3QY8CCwFEjNm+Q4l9GBA1ZZ/txzlhsBCyJffBHddDnn0kUSSHao6ud5lhLnQhw6BIMHWwDZFRi+s3FjePttaN8+umlzzmUUSSB5SkTeAb4BkoIrVfWzXE+VK7aOHIF337UAsmULxMdb5fk//mF1ISVKRDuFzrljRRJIbgWaAaVIL9pSwAOJy7HkZPjwQ3jmGdiwAerVs7nOO3SwwRTLlIl2Cp1z2YkkkJypqj6snct1CxfalLU//mjT2oJNZ3vBBfbeg4hzBVvYPduBOSLSPM9S4oqlhQuhUyebG6RkSSu6GjIEZszwsbCcKywiyZFcBPQRkZ+wOhJv/uty5IcfbHj38uVh926bWOqVV6yToXOu8IgkkHTOs1S4YmfZMpvKtmJFy32UKGF9QpxzhU+ko/9mWsI9XkSGish2EVmWzfYOIrJHRBYHlidDtnUWkdUikigij4T7na5gmjzZxsHat886GDZs6EHEucLshIFERBbmxj7YhFUnytXMVNXWgeXZwLlLAIOALkBz4HqvqymcVG0+9M6drZXWv/8NN9544uOccwVbOEVbcSKy5DjbBah4opOo6gwRaRBuwkK0BRIDMyUiIiOBBGDFSZzLRdH118OoUVaM9cUXFlCcc4VfOIGkWRj7pOQ0IQHnB+Zm3wI8oKrLgbrAxpB9NgHn5tL3uXyydq1Nc1uyJHz5pVWyO+eKhnBG/w27HiSHFgKnq+p+EekKjAUaYzmeTMnK7iQi0g/oBxDrBe9RdfSozZm+fLnNEVKqlE1960HEuaIlklZbeUpV94a8nygib4hINSwHUj9k13pYjiW78wwBhgDEx8dnG3Bc3tq6Fa64wvqJAFx5Jbz5JtStG910OedyXyQdEvOUiNQSsSmJRKQtlradwDygsYg0FJHSQC/AB48swKZNs3nTFy60PiLDh9t86R5EnCuaTipHEmg1dTqwVFU3hXnMCKADUE1ENgFPYeN2oaqDgZ7AnSKSDBwCeqmqAskichcwGSgBDA3UnbgCaPp066muCpdcAh995POFOFfUid2rIzxI5BPgE6AFVq/RJ7cTlhvi4+N1/vz50U5GsXD0KAwcCI8/bkObDBxoo/X6tLfOFS4iskBV4yM55mTrSL5S1Y+Bj0/yeFeEfPedNeXdvx969LB5RGrWjHaqnHP55WTrSC4Qkc9E5G0R+WuupsgVGqmp8MgjNtTJ/v1w333w2WceRJwrbk42R7JMVf8lIiWB3+dmglzhsGWL5UKWLoWyZeHzz+EPf4h2qpxz0XCygeQKEUkCJqvqD7mZIFfwffml9VLfs8fGyZo92yvUnSvOwhlrK6ue7dcBa4CrReTtXE+VK5BU4W9/g65dbZDF556DFSs8iDhX3IWTI5koItOAp1X1ZwBV/QWYFFhcMXDgANx8s9WBXHEFfPwxlCsX7VQ55wqCcCrbmwGLgOki8qqIVM/jNLkC5uefbdrbzz6zz1de6UHEOZfuhIFEVY+o6utAHDZcyfci8qyIVMjz1Lmomz3b5g5ZtswGXBw2DPr1i3aqnHMFSSQTWx1W1X8BLYHDwEIReSDPUuaibuxY6NgR9u61llkTJ8INN0Q7Vc65gibsQCIiDUSkM/AnIBbYB/w9rxLmouvtt+GPf4Qzz7Rmvt984817nXNZO2Fle2BSq3rAz8AqYCXwLTZr4eo8TZ2Lin/+Ex56yIZ7HzvWBl50zrnshNNq6ypgnZ7MoFyu0HnpJXj4YShTxoqzPIg4504knImt1uZHQlz0BYNI6dJQtarlTJxz7kQKzMRWLrpCcyLVqtlw8L/7XbRT5ZwrDDyQuLQgUrWqNfH99lsPIs658BWYGRJddLz9tgWR666D77+31llNmkQ7Vc65wiScVlv7gKwq2gVQVT0tnC8SkaHAFcB2VW2RxfbewMOBj/uBO4MDQorIeqy5cQqQHOmkKy5rkyfDHXdY7uODD6xuxDnnIhVOZXtu9WB/D/gP8EE2238C2qvqbhHpAgwBzg3Z3lFVf82ltBR7K1ZAz55QqhRs3w4bNkDjxtFOlXOuMIqojkREKgONgbLBdao6I5xjVXWGiDQ4zvbZIR/nYH1XXB7YswcSEiApCWJiYPx4DyLOuZMXdiARkT8B92A3+MXAecD/gE55kK7bgS9DPiswRUQUeEtVhxwnnf2AfgCxsbF5kLTCLTUVbroJEhMtiIwcCe3bRztVzrnCLJLK9nuAc4ANqtoROAvYkdsJEpGOWCB5OGT1haraBugC9BeRdtkdr6pDVDVeVeOrV/eBio/14ouWAylVCgYNgquvjnaKnHOFXSSB5LCqHgYQkTKqugpompuJEZFWwDtAgqruDK5X1S2B1+3AGKBtbn5vcTFlCjz+OPTqBWvWWEW7c87lVCR1JJtEpBIwFvhKRHYDW3IrISISC3wG3KSqP4asLw/EqOq+wPvLgGdz63uLi/Xr4aqroE4deOcdH/rEOZd7wg4kqnpV4O3TIjIVqEgEMySKyAigA1BNRDYBTwGlAuceDDwJVAXeEBFIb+ZbExgTWFcSGK6qPjNjBA4dspF7Dx6Etm3hlFOinSLnXFFyUj3bVXX6SRxz/Qm2/wkbov7Y9euAMyP9PmdUoXdvq1w//XQYNw4sJjvnXO4Ip0PiLFW9KIuOiRF1SHTR8fLLMGaM5UKmTYPT/K/lnMtl4XRIvCjw6lPrFjLffw+PPGLNfCdNggYNop0i51xRFMkMif8IZ50rGHbtgmuvhfr1YeFCuPjiaKfIOVdURdL8N6uJVrvkVkJc7lGFSy6BzZvh449tulznnMsr4dSR3An8BWgUmHY3qAIwO+ujXDTdcw8sXgytWsE550Q7Nc65oi6cVlvDseFKXgAeCVm/T1V35Umq3En78kt4/XXrJzJtWrRT45wrDsKpbN8D7BGRW4GrgQbB40QEVfXOgQXE9u3W6VDEKtcrV452ipxzxUEk/UjGAnuABUBSnqTG5Ui3bjai71NPwUUXRTs1zrniIpJAUk9VO+dZSlyOfPopzJ9vI/s+/XS0U+OcK04iabU1W0Ra5llK3EmbNw/69YOzz4ahQ6OdGudccRNJjuQi4FYRWYcVbQV7trfKk5S5sCQlweWXw+7dNt96yZMa9MY5505eJLcd7zNSAF1zjQWR3r2hdetop8Y5VxxFUrT1M3Ax0EdVN2DjbtXMk1S5sHz8sU1SVbUq/Pe/0U6Nc664iiSQvAGcDwRH8d0HDMr1FLmwbN4MffrY+88+sxkPnXMuGiIJJOeqan/gMICq7gZK50mq3AklJsLhwzbbYbtsJx52EZk502YAc85FJJJAclREShAYSl5EqgOp4R4sIkNFZLuILMtmu4jIayKSKCJLRKRNyLbOIrI6sO2RrI4vTpKT4YEHoGZNePPNaKemEErN4p/tV19Bhw7QqRPs3ZvvSXJZUIVff412Kk7O669bx66DBzNvGzUKFi3K/zTloUgCyWvYfOk1ROR5YBY2bEq43gOO1w+lC9A4sPQD3gQIBK9Bge3NgetFpHkE31ukLF0KTZpYn5FXX4VKlaKdokLmL3+Bpk0z5jyWLbOs3emnw4YNto+GTL2TkgJTp1oEL6hC0xvqxx9t8LVdhXA0o/vug+rVrX37sVavhjVr8j9N4Zg5EwYMgIkT4eab4cgRW68KL71k/9bi42HPnszHZvd3zE0pKXDnnbB8ea6dMpKpdoeJyALgEqzpbw9VXRnB8TNEpMFxdkkAPlBVBeaISCURqY0NyZIYmCkRERkZ2HdFuN9dVCQl2b/B9euhY0e47rpop6gA27ABYmMzTgf53nvpWbhzzoH+/eHAAXjjDahYEaZMgZEj4YknLNfy1FM2T/Gjj9qYMw88AP/8Z8bv2b/f/iAtWuTXL8ts0ybLSfXubWkO2rzZcllbt9oTyGefQZkytq1ECXjwQSsj/fBDq2RTTb+RlS9vbcmTkuwaBbcdPQrTp0NCApQrZ9v27bNj1q+HlSutPXrNmvYde/ak3zBDzx8baxPl7NxpzQ6P3f7TTzBwoL3v3h0++gjq1rXPixbBDTfY8XPnZp47OjERLrvMfuvPP9vfKFTp0nDGGelpPnAAhg+HbdsseJUrB7/7nW1fu9Z+X2i7+lNOgUaNYMsWu969ekGNGun79+ljT3u9esGzz8Lvf29/h0WLYMECm9th40a48UbbHhN4np82zc73j3/An/9s6xYvTv9N339vv7tGDbsWKSmwZIk94IjY9QaoVQtq17a/1bIsCoCGDYPBg21U16RcGqREVcNagH+Es+4E52gALMtm2xfARSGfvwHigZ7AOyHrbwL+E873nX322VqUPPyw/U8rU0Z17dpop6YAe+89u1APPqianGzrhg9XLVVK9cILVb/9VvWCC2yfmBjVDh1UP/lEdfJk1XHjVK+/3tYHb22lSqW/v+oq1ccfV50wQXX7dtUmTWx9QoLqrbeq3nSTHT9qlOqjj6r+/e+qnTurXnKJavv29v1t26o++aTqoUOqP/2k2rKl6u9/rxoXp9qwoWqVKqoffGDpXrJEtV491Tp1VGvVUq1eXbVqVdXRo237t99mTKuIfX7wQdXYWNWyZdO3hS4tWmS9PrhceKHqwIGqb72V9fZevVRTU1X/9a+st2/ebOl76qmst+/da9v/+test1esqNqqlWr37sdPZ6VKWa/v2dPSd+WVmbc1apT+b6VDh8zbzzorfXvz5pm3t2unumePpS+r7y5dWnXdOju+SpXM26+7TvWNN+x9iRKZt5csqbpggR2f1fnvu8+27duX9fYnn7TtW7Zkf91uvll19eostwHzNYz7a+gSST+SPwAPH7OuSxbrTlZWM4nrcdZnfRKRfljRGLGxsbmTsgJg9mzLFYM9TDRqFN305LnU1PQntZUr7Wnxt9/Sl6pVrdgALMewdq09We7ZY0+pYLmH0aPtif3oUVv33Xf29H7ddVYXUrKkPT1fc03G77/2WvjDH+zp9dZb09ePGQNjx1rRxMaNli6wdtg1atjTbMmStn7qVNvWpAlUq2ZP/WXLWrn/s8/CDz/Af/5jT8cxMZbGKVOsFcWYMTbezWmn2dN1cjJMmGDFJAkJ9kR/8KDNpZyaCl27WvHV99/b53/+04rwhg2z67diBXz+efrT+ebNlkObPt3ajrdubbOf7dljRTLffWfLww/DK6/Y0+8XX6QPKT1ypI0KesUVVowzfLjlLlShQgX7jXXqWG4iORleeMGu85NP2jUI5oyCOcZ69ex3/fabXd/SpWHcONixw1qTvP++PV2XKmXp/PhjK9/t3t1yCK1b299j40Y73+jRNj3oAw/Yk//PP8Pf/265nzJlLMdTt65N1jNzJjRubOmeN8/SPWOG5R5++in9b9+uHfTsae87drRretttdg3XrrX1rVvD449Dw4b2+cMP7e8Z+u+5Xj1o29b+tn/5i/07jImxf5fdu8Pzz9tvvOMO+zx5sl2z006z33f0qP2dfvjBfsPmzXbenj3ttzZtap+/+spemzWzf8tr19rw4C1bWi5c1a7xsRISMq87kRNFGuBOYClwAFgSWJYCPwEfRRK1OH6O5C3g+pDPq4HaWJPjySHrHwUeDef7ilKO5MIL7YHh6qvtQatQSUlR3blTdeVK1enT7Wl62LD07U8/bU/rLVqo1q+vWqGCPaUHnX9+5ientm3Tt3fubE/z8fH21A6qffuqfvyxPZE2bqzapYvq88+rvvqq6uDBqt98k378V1+pfv216qxZqvPmWS5gy5b07bt3qx44YE+hDz6oWrmyPfV36qS6cKHtX6WKpfvmm1XbtLE09OljT7dlytiT++zZqnfemfF3XH+96po1qlOnqjZrZjmIs8+2bXfdpbpxo+rMmRlzEGXLql52mf1WEdWXXkpP68aNdn2nTVM9ejTj3+HQITvXzJn2XtX+Mf3tb/YUHfrE/tVX6U/zdeqkP1nffbfl8u6/P+PvqF9f9X//s79x1aq2/xNPqN5zT8Zc0SWXqP7yi6Xtn/+09Jcokf53A9WLL846y52UZP+WQi1fbk/4DRvav5P337d9/vxnO1dcnP37KFVKtWZN1cceUz3llPScA9i13LXLzn/vvRlzCR07qm7YYDmr0PVVqqiOH5+ejm3b7ByROnJEddUq1d9+S1+3ZYvlfEuUsOXqqy0Nhw6pXnttxuteq5b9rW+7zT7fdpvql1/a30dEM+TaSpa0/xfB3GA2OIkcSTg3/4qBADACOD1kqRLxlx0/kHTD5j0R4DxgbmB9SWAd0BBrbvwD8Ptwvq+oBJK9e1UbNFCtXdvuaQXOjh2q339vN7BXX1V94AEr5gm64YbMgaBKlfTt995rN48ePey4e+9VfeUV2zZ6tJ1v2jTVxYtV16+3i3DsTVJVdcQIO/ejj+blr7Wb77E3tLVr7T957doWSD74wPbbscOCWPB3x8TYzfXIESv2Cr05BW8Kycm2T+j1qlFDdcoU1Z9/tptkmzZ2g5kxI3d+07ZtqmPH2vcfOWLrUlIs4N9wg92gQoOvqt3E33jDigWDgUlV9ccfVS+91G5kpUpZsPzlFytyLFXKlgoV0p+MDh2ym/iCBRZUc0NqqhVntm+veuaZdj1/+cW2bdyo+uKLqg89ZEWUxz6ZbdmiOmmS/b7QbYmJqkOG2L+zPXtyJ53Hc/iwXZdQqan2N3/xRbuewXQkJ1vZd8mSdl1F7G924ICd49hgdRwnE0jEjguPiJyJ9W4HmKmqP0Rw7AigA1AN+AV4CigFoKqDRUSA/2Atuw4Ct6rq/MCxXYFXgRLAUFV9PpzvjI+P1/nz54ebxAJpzRqrfxs1ynLQURkePjXViocSEzMuH31kxQoPPGBFLEFly1r2fdkyK0b48ktrPZSaCs2bW2VgjRpWIQhWLPTEE/Yjg9lysKKhTp3s/YQJVnwTtGOHZcHbtLEirilTbNjjCy6wLH2w6KSgWLLEGgCcdZZdm6C1a22QtIoVrZiofPn0bcuWWVFSlSpw5ZVW9FKY7N9vxXxly6avW7XKiqn27YPOna2JrGRVeu1Oyo4dVpR5xhlWRHcSRGSBqsZHdFC4EQcYACwDng0sS4G7I41c+bkU9hzJ4cOqdetqhvqzPLdtmxXzvPqqvVe198dWJsbFWXZbVXXpUsvmL1qkunVr+hNtqClT7NhgJWjQ6tWq5cppWpHKihW2/ptvLNfSsKEtp51mxS2q9mR45pmZczk9e54w2+6cOz7yomgrbUerGykf8rk8sCTSL8zPpbAHkgED7C/UrFnWJTk5FryhL11qxUp16mS8MU+YYNtXrEivV9iwIb0l1LEOHrTy/bZt7X3Qtm1WPh087+2323kmTrSioOrVVUeOtLL1mJj06Nm4sRUZ/fyzBS6wlkglSljRyOTJ1urp00/tNzjncuxkAkkkrbYESAn5nELWLapcLli40DrHlipljWhyZXj4LVusuGjqVJg1C+6/H/r2tS9Zvtxaopx9trUvb9TIiq5atYK4OFuCxoyxpmPDhllrpKB777WWLmDFTm++aa13br3VWqb88IO19nnhBXj3Xdvvd7+zVjotWlhb+zfesOKec86xtAX7CMybB2+/ba+NGlmLlmC/ggYNcuHiOOdOViS3p/8C34vImMDnHsC7uZ4iR0qKFYmrWjAJtiSMWLDJ4cGDVjb/44+2vlIla15Yo4Z1HmvWLH1b0F13waBB1mR09uz0USFXroSrr7b3XbrAJ5/YeZ54AoYMseaiTZtaz9lgp6/q1S0atmplS+/eFsxq1bJ6gWAZes2a8MwzWf+W8uUtULli4ejRo2zatInDhw9HOylFVtmyZalXrx6lcmPE10iyL0AbrK7kHuCsSLM/+b0U1qKtCROsFOeii07i4NWrVV9+2Zot9uxp6x5/3OoYnnnGmqsGi6ZCO4u99lr6OQYOtHXB4qgePaw1TbAoqmZN1UGD0ptRBluK9O+ffu6ffrJ93nuvgDY1cwXZunXrdMeOHZpa6Nq6Fw6pqam6Y8cOXRfsOBmCvKwjKYxLYQwkycnWZeD008NurWcefTRjX4AWLax/wIwZ6esuvthOmppqzRhFrGlnsPdwp062TzB4HD1qQSW0iWqjRqrLltl3btig+txzqo88Yn0TnMslK1as8CCSx1JTU3VFsHFLiDwNJEBZ4K/AZ8CnwH1A2Ui/MD+XwhhIgl0uPv44mx0OHrRA8Ouvqq+/bk279u1L73R06qk2bIaq6g8/WP+DM85Qffttq8iuVs2G4wh2xDp4ML1PQ/Pm1hHw5Zcz1u6vXav65puWqND+As7lkaxucC735VYgCbsfiYh8jE1m9VFg1fVAZVW9Jvujoquw9SOZONGa1detayMhZGpe/+uvVp9xyimwfbsNuPbll/DBBzBihA23ERxoMD4e5syxoUSmTrV6i7lzbcjgXbusEubPf/ZJ3l2BtHLlSuJCG3i4PJHVdT6ZfiSR3EWaquqZIZ+nikjYHRLd8SUlpc94OHRoFkFk82YbRXTPHhvTqE4dO+CFF2xcoL//3UazveIKG8dp+XLo18/G/akZmBG5bVsbE8k553JRJIFkkYicp6pzAETkXOC7vElW8fPMM5bhaNsWLjtvL2zaa72dFy+2FlbjxlkQ6d7degQ/+aQFkerV4Z134Pbb7USnn57etNY5lycuvvhi9u3bR8mSJSlMpR55JZJAci5ws4j8HPgcC6wUkaWAqmqrXE9dMbFhQ/o0F+++C/zxj/D111aEVbKkjWL6xBMWQMaMsSa9ffvaCLO1annxlHP5bObMmdFOQoESyR3oeLMbuhzYt8+aRPVMOEqLT56zIALp03Q+9pjVaQwfnj4UdcmSGcdscs65KIlkhsQNeZmQ4uytt+z1lRsXwDXPWgXJuHEWXdassd7m7dv74HbO5aPExESuuuoqli5dmrYuKSmJZs2aMWHCBJo3L7YzfmfiZSJRlJICd1+1icMTvuG22/tQ77x6NmrtDTdYDsQ5FzWNGjVi48aNpKamEhMoCRgyZAjt27f3IHIMDyTRosp3tw3lxfH3EUMqe/p3syIssIp051xUxcTEEBsby/r162nUqBGHDh3i5ZdfZlpwlkiXJuxAEpgvpDfQSFWfFZFYoJaqzs2z1BVVW7dy9Na+tJs8gW/pyIyb3+XpAz/atJyPPOKDEDoX4t57rfFibmrd2rpUnUhcXByrVq2iUaNGDBo0iO7du9PA/39mEkmO5A0gFeiEzUeyD+vhfk4epKvo2r/fJmP69TcGMJB3ytzFhr+sh57X2eiMjz4a7RQ65wLi4uJYvXo17dq1Y9CgQcyZMyfaSSqQImr+q6ptRGQRgKruFpHSkXyZiHQGBmIzHb6jqi8es/1BLNcTTFscUF1Vd4nIeix4pQDJkfa8jDpVqyw/9VR++b/XeHzAHl7hXu6uNZ7qf/jeWmFNnQqnnRbtlDpXoISTc8grcXFxfPvttwwcOJDevXtTs2ZNtm3bxnXXXUe3bt1Yvnw5F1xwAV999RVPP/00LVq0iF5ioygmgn2PikgJQAFEpDqWQwlL4NhBQBegOXC9iGSosVLVf6pqa1VtDTwKTFfVXSG7dAxsL1xBZOdO6wMyejQAZW/syZ0l3+FUDtCw/C9WsT5vHpx55glO5JzLT3FxccydO5ehQ4fy4IMPArBo0SKuvvpqHnroIfbs2UPfvn255ppr2LCh+DZsjSSQvAaMAWqKyPPALODvERzfFkhU1XWqegQYCSQcZ//rgRERnL9gWrMGzj3X5t7evx+AcffPoM3R71n0p0GUXL7EJoj63e+im07nXCZNmzZl6dKl9OvXj4oVKwKwePFiLr/8co4ePUrVqlWJiYlh2bJltGzZMsqpjZ5I+pEME5EFwCWBVT1UdWUE31UX2BjyeRPWWz4TETkF6wB5V2gSgCkiosBbqjokm2P7Af0AYmNjI0heHpgzJ70Z7/Tp6LnncXUP5b5xT7KnTHXOeu3W6KbPOXdcZcqUITk5OcO6xMREmjRpwpIlS9IGPFy/fn307zdRFEmrrTLYxFYVA8ddIyKo6rPhniKLddkNPXwl8N0xxVoXquoWEakBfCUiq1R1RqYTWoAZAjb6b5hpy31r1tjUtRUqWGus885j4gSoOu5d2jGD/c8PhnLlopY859zJeTcwll3r1q1p3bo1AB9++GEUUxR9kRRtjcOKopKBAyFLuDYB9UM+1wO2ZLNvL44p1lLVLYHX7VgRW9sIvjv/nXGGTVe7Ywd07kzKt9OZ0vt9/sNdbP39pZx675+inULnnMsVkbTaqqeqORlvax7QWEQaApuxYHHDsTuJSEWgPXBjyLryQIyq7gu8vwxrglzwTJxoY2C1amWjMQJUrEiJSzowEPih/Pm0mj4KSpSIajKdcy63RJIjmS0iJ12bpKrJWJ3HZGAl8LGqLheRO0TkjpBdrwKmqGpobqcmMCsw/8lcYIKqTjrZtOSZb7+FHj2sU+GyZdZK69FHObRyPX1KDecKmUDlpTORqlWinVLnnMs1keRILgJuEZGfgCSsziOi4eNVdSIw8Zh1g4/5/B7w3jHr1gEFu23sDz9YEGnSxFph9e1r9SMPPMDIcZX44Oj1/PWvENsw2gl1zrncFUkg6ZJnqSjs1q+HLl1sIqpJk2D+fPj0U3j6abYnV+H+++HCC9PnHHHOuaLEh5HPDddfb/Ogz55trzfcAHFx8NBDXHWpTWz41lvpU4k451xREtHovyJSGWgMlA2uy6oJbrFy6JD1FwHo1MlmqapZEz7/nFkLyjF7ts1++/vfRzeZzjmXVyLpR/In4B6s2e5i4Dzgf9ggjsXTmDE2/AlYBfuOHTb17d13ozVqctMfbJNPoe6cK8oiKWy5Bxvpd4OqdgTOAnbkSaoKg1mz4Jpr4LnnoG5de33nHXutWZMPP7Sqk5Yt4ZJLTng251wB1alTJxITEzMNgZKUlETDhg1ZsWJFtsfu3r2bq666Kq+TGHWRBJLDqnoYrJe7qq4CmuZNsgq4vXvhxhutv8imTdC7d4Z+IcnJ8Ne/2vt33olSGp1zObZ8+XKqVq2aYbbEoHBmS6xcuTK7du1iZ7DkooiKJJBsEpFKwFhsiJJxZN8zvWgbMAA2brSmWAB33JFh8wcfWIlXr17QtmD3v3fOHce4cePo0aNHhtkSgbTZEp9++ukTnqNbt26MHz8+bxMaZWHVkQRmRxygqr8BT4vIVGzMrYLXKTCvjRsH778PDzxgTbGuvdYmpAo4fBieesoCyPDhUUync0VIhw6Z1117LfzlL3DwIHTtmnn7LbfY8uuv0LNnxm3hzpY7ceJEvvjiC+DkZ0tMSEjg4Ycf5pZbbgnvSwuhsAKJqqqIjAXODnyenpeJKtDOOQcC8xKwbx889FCGza++aqVd//qXzWPlnCucDh06xJEjR6hUqRJw8rMlNm3alNWrV+dhSqMvkua/c0TkHFWdl2epKchSUmD1amje3Capuvxye9wJjP4JVnXyt7/Ze5/W2bncc7wcxCmnHH97tWrh50BClStXDhFh//79nHrqqVnOlgiccMbEDRs20LBh0R7SIpI6ko5YMFkrIktEZKmILMmrhBU4jzxinUFatrRA0qRJpjlAX3rJstnnnGNzWTnnCrfLL7+cSZOsBD+r2RLhxDMmjhs3joSE483hV/hFEki6AI2wfiNXAlcEXos+1fTOIGXLwq23wowZNiRKwI4dVpwFFlCcc4VfQkICY8eOBbKeLRFOPGPi+PHj6d69ezSSn28iKdr6BfgLNnijYlPtvpkXiSpwPvsMdu+G9u2zzSO//DIkJcFZZ9luzrnC7+yzz2bp0qUkJydnOVsiHH/GxN27d5OUlETt2rXzO+n5SlTDm0RQRD4G9gEfBVZdD1RW1WvyKG05Fh8fr/Pnz8/ZSY4etfnUN260YeH/+MdMuxw8aH0STzvNGnJ1zsmsLc45Vq5cmXZTdnknq+ssIgtUNT6S80SSI2mqqqFDuU8NzA9StL3/vgWRkiWtgj0LH30Ev/1mLYPbtcvf5DnnXLRFUkeySETOC34QkXOB7yL5MhHpLCKrRSRRRB7JYnsHEdkjIosDy5PhHptnrr0Wate2huynnpppsyq88ILVvV98cb6lyjnnCowT5khEZClWJ1IKuFlEfg58Ph3IfpCZzOcpAQwC/oDN3z5PRD5X1WPPMVNVrzjJY3Pfzp2wdWum/iJBkyfbmFrVq0Nqqs+g65wrfsIp2rrixLuEpS2QGJjtEBEZCSQQXjDKybEnJyXFBmUMtBWnS9bzej31lL0+9pgHEedc8XTCQJKLE1rVBTaGfN4EZNXb4vxA3csW4AFVXR7BsYhIP6AfQGxs7MmnduxYGya+cWPrO9I08/iUy5fD3LlQrpzNrOucc8VR2HUkIhIvImNEZOFJdkjMasCQY5uMLQROD1Tqv44NEBnusbZSdYiqxqtqfPXq1SNI3jFefx3q14c1a2x03yw8+6y93nknlC9/8l/lnHOFWSSttoYBDwJLgdQT7JuVTUD9kM/1OGb0YFXdG/J+ooi8ISLVwjk2Vy1fDtOnwx/+YC22brgh0y6//moZlnLlsq0+cc65YiGSQLJDVT/PwXfNAxqLSENgM9ALyHCHFpFawC+BQSLbYjmmncBvJzo2V735JpQpA6tWWWut+vUz7TJ4sHUxmTcvvRrFOeeKo0gCyVMi8g7wDZAUXKmqn4VzsKomi8hdwGSgBDBUVZeLyB2B7YOBnsCdIpIMHAJ6qfWYzPLYCNIemYsuspZan30G//lPps1HjsDAgXDZZXDmmVkc75xzxUgkgeRWoBnWDDhYtKVAWIEErLgKmHjMusEh7/8DZL5zZ3NsnmnfHu67D+Lj4YrMjdY+/NCKtkqXzpfUOOcKKMmnuSLCHYEkWiIJJGeqassT71aI7d9vWYxffrHPb78NMRnbI6imV7Lfd18+p885V6A8/PDDPP/885Qo5m3/I+nZPkdEsp+cuCiYNAnWrbPgMW1ahrlGgqZPh59/hjp1oGPHfE+hc66AUFVUtdgHEYgsR3IR0EdEfsLqSASbPLFVnqQsGoYNs9eJE61YKwtPPGGvjz3mMyA6V5zNnTuXc845J+LjLr74Yvbt20fJkiXJ8aCyBUQkgaToj2k7a5blRi64IMvNa9faLsEpSZxzxdeUKVO49957Iz5u5syZuZ+YKIukaOtn4GKgT6C3uwJFp+HrTz9ZDXqdOpnqRYJee80GAR4/3qb3dM4VX/v27aNChQrRTkaBEEkgeQM4H5uHBGxukkG5nqJomTXLXrMp0tqzxyZJ7NULLr00H9PlnCtwNmzYQIMGDXJ8nrFjx9K3b18SEhKYMmVKzhMWJZEEknNVtT9wGEBVdwNFpwFscE7lbCZbf/NNOHDAht1yzhVv48eP58orM880PmbMGESEVatWpa1LTExMm3Y3KCkpiYYNG9KkSRPefvtt3nvvPUaNGpXn6c4rkQSSo4Hh3BVARKpzckOlFEwrV9prFrOyJSenz8eeTYbFOVdEHT16NNO6n3/+mfpZjHgxYsQI4uPjGTlyZNq6Ro0asXHjRlJT02+XQ4YMoX379jRvbg1hn3vuOfr3758Hqc8fkQSS14AxQE0ReR6bs/2FPElVfps4Ee64w943z9zCecwYm5akfn1v8utccTJjxgyaNGnC/v3709bt3buXihUrZtp3//79TJ8+nXfffZcRI0akrY+JiSE2Npb169cDcOjQIV5++WWefvppVJWHH36YLl260KZNmzz/PXkl7ECiqsOAh4C/YwMmJqjqx3mVsHw1caIN1Fi6NDRsmGnz3/5mrw8/7E1+nStO6tSpQ7NmzZg0aVLaukmTJtG5c+ZGrGPHjuXSSy+lVatWlC9fnoULF6Zti4uLSyvuGjRoEN27d6dBgwa8/vrrfP3114wePZrBgwdnOmdhEc4MiccO1Bi8lV4uIqhq99xPVj779luoVMmm1C2Z8ZLMnQtLl9oYjjffHJ3kOVes3XsvLF6cu+ds3RpeffWEu51xxhncfPPNjBs3jp49ewKwcOFCrr322kz7jhgxgn79+gFw7bXXMmLEiLRcRlxcHKtXr6Zdu3YMGjSIOXPmADBgwAAGDBiQO78pisLJkZyPDds+E/hXyPJyYCnctmyx+pGUlCyLtV591Zr6vvQSeEs/54qfrl27MmXKFJKTk0lJSaFkyczP3zt37mTu3LlpOZXrrruOUaNGpY2RFcyRDBw4kN69e1OziA0ZHk6HxFrYXOnXY0O3TwBG5Onou/lp6lR73bUrU0X75s3wySdw991QBB4anCucwsg55KWKFSvSsmVLZsyYQYkSJbjwwgsz7TN69Gi6du1KmTJlAGjYsCG1atVi1qxZXHzxxcTFxfHiiy/y9ddfZyjyKipOmCNR1RRVnaSqfYDzgERgmojcneepyw9ly8J559n7Y3Ikgwdbi63uhb/wzjmXAwkJCYwbN46pU6fSqVOnTNtHjBjB+PHjadCgQdqycuVKhg8fDkDTpk1ZunQp/fr1S6uo37ZtG+3bt+ell16iT58+vPXWW/Ts2ZNly5bl62/LDWENkSIiZYBuWK6kAdaCK+zh4wu0P/4RDh+GOXMyBJIjR2BQoLvl2rU2v5Vzrnjq3r07HTp0oFevXmm5jlDTpk077vFlypQhOTk5w7pFixZx9dVXc88999CjRw/69u1LpUqV2LBhAy1atMjN5Oe5E+ZIROR9YDbQBnhGVc9R1b+p6uZIv0xEOovIahFJFJFHstjeOzAf/BIRmS0iZ4ZsWx+YJ36xiOTOSGcpKRYxVqywSvYzzkjb9OmnsHu31Y/06pUr3+acK6ROP/10TjvtNJo1a5Zr51y8eDGXX345R48epWrVqsTExLBs2bJMnRcLg3ByJDcBB4AmwICQiVyCo/+eFs4XBTozDsLqWzYB80Tkc1VdEbLbT0B7Vd0tIl2AIUBoV/OOqvprON8XliVLrFjr7LMtiITMVPXKK9bUt08fKF8+177ROVdI9e3bl27duuXa+RITE2nSpAlLliwhLlA/u379emJjY3PtO/LLCQOJqkbSafF42gKJqroOQERGAglAWiBR1dkh+8/BWovlnXnzLEfyyy8Z5sxdtMg2QXo/Redc8XbXXXfl6vneffddAFq3bk3rwNxHH374Ya5+R37JrSARjrrAxpDPmwLrsnM78GXIZwWmiMgCEemXKymaPx8qV4YNGzK02Bo0yEq6LroIWhWd2Vaccy5P5GcgyapPeJYTEYtIRyyQPByy+kJVbQN0AfqLSLtsju0nIvNFZP6OHTuOn6IFCyyApKRA06aAtQIeNgxuu81mQ3TOOXd8+RlINgGho5zVw4ZayUBEWgHvYEOw7AyuV9Utgdft2JhfbbP6ElUdoqrxqhpfvXr17FOTmgqrVkHVqvY5UIk2dKg14urfP9tpSZxzzoXIz1vlPKCxiDQUkdJALyDD8CsiEos1K75JVX8MWV9eRCoE3wOXATlrbH30KDz+ONSqZZ+bNiU11Yq1SpSAsWNzdHbnnCs28i2QqGoycBcwGVgJfKyqy0XkDhEJVmk/CVQF3jimmW9NYJaI/ADMBSao6iRyokwZePRR63FYuzZUrMjMmbB+vZV0+Si/zjkXnkjmbM8xVZ0ITDxm3eCQ938C/pTFceuAM49dnyNbt1rEWLkyrX5k9Ghr8tuokVW0O+ecO7HiWwvwj39YRfuqVdCsGampMGoUqMKtt/pw8c45F67iG0g2bIC6deG336BZM777DnbssADiw8U751z4im8g+flnm4MEoFkzRo+2ju2jRtlMiM4558KTr3UkBcqGDRAYGC21STNG3wZdu8I110Q5Xc65QkEKafl3cI6U3FQ8cyQHDtgk7CkpUK4cczbXZ8sWqFEj2glzzhUGGzduTJu4qrAteaF4BpKYGPjgA6sQadKEj4bbZUhJiXK6nHOFwuTJk7n88sujnYwCo3gGknLl4KabYPNmtFkzRo2y1X37RjdZzrnCYc+ePWkTVLniGkjAxkH56Se2VWzGrl1WrNU2y0FXnHMu3f79+6lQoUK0k1GgFN9AkpgIqkzZYJ0Rb7nF+444505s8uTJXHbZZdFORpqxY8fSt29fEhISmDJlSlTSUHwDyapVAHy6vBkVK8KfMvWnd865zH766ScaNGiQYV2nTp3SptI9dOgQ7du3JyWk0nXMmDGICKsC9x2wia2OnQ0xKSmJhg0bsmLFCrJz5MgR2rVrl/Z9PXr04O233+a9995j1KhR7N69m6uuuiqnPzMixT6QfLOpCc88A40bRzk9zrkCKTU1Ne19SkoKJUtm7DWxfPlyqlatmrZ+6NChXH311ZQoUSJtnxEjRhAfH8/IkSPT1jVq1IiNGzdmOP+QIUNo3749zZs3zzY9pUuX5pJLLmFUsHI34LnnnqN///5UrlyZXbt2sXPnzmzOkPuKdSD5rWIsBylPjx7RToxzrqBJTU3lmWee4YknnkhbN3v2bC644IIM+40bN44eITeRYcOGkZCQkPZ5//79TJ8+nXfffZcRI0akrY+JiSE2Npb169cDlpN5+eWXefrpp0+Yth49ejBs2DDA+oU8/PDDdOnShTZt2gDQrVs3xo8fH+lPPmnFOpD8cLgpIjZJonOuAOvQIfPyxhu27eDBrLe/955t//XXzNvCICLcd999fPPNN2nr5s+fzznnnJNhv4kTJ6bN5X7kyBHWrVuXoehr7NixXHrppbRq1Yry5cuzcOHCtG1xcXFpxV2DBg2ie/fumYrNstKiRQvmBeYDf/311/n6668ZPXo0gwfbGLgJCQmMzce5MIpnz3ZVUlet5oekW/ndGXDaadFOkHOuoBERTjvtNOrXr09iYiJnnHEGqampGXq0Hzp0iCNHjlApMNzSr7/+mvY+aMSIEfTrZ7ODX3vttYwYMSIt5xAXF8fq1atp164dgwYNYs6cOWGlrUSJEpQuXZp9+/YxYMAABgwYkGF706ZNWb169Un+8sgVz0CyZQsxB/azimbcfnu0E+OcO6Fp07Lfdsopx99erdrxt59AQkIC48aN48orr6RpYMqJoHLlyiEi7N+/n1NPPZVy5cpx+PDhtO07d+5k7ty5fPbZZwBcd911tG/fnpdeegkRIS4ujm+//ZaBAwfSu3dvatasGXa6kpKSKFu2bJbbNmzYQMOGDU/i156c4lm0FchKrqYZ/ftHOS3OuQKtW7duTJgwga+//ppLLrkk0/bLL7+cSZNsnr3KlSuTkpKSFkxGjx5N165dKVOmDAANGzakVq1azJo1C7Acydy5cxk6dCgPPvhg2jm3bduWFnD69OnDW2+9Rc+ePVm2zCaG3blzJ9WrV6dUqVJZpnncuHEZ6mnyWr4GEhHpLCKrRSRRRB7JYruIyGuB7UtEpE24x0biwAILJClnNMX7FTnnjqdy5crExMSwdetWypUrl2n7sfURl112WVqgGDFiBOPHj6dBgwZpy8qVKxk+fDhgRVBLly6lX79+GXrKL1q0iKuvvpqHHnqIPXv20LdvX6655ho2bNgAwNSpU+natWu2aR4/fjzdu3fPjZ8flnwr2hKREsAg4A/AJmCeiHyuqqENprsAjQPLucCbwLlhHhu2zd+sojancsezdU7+Bznnio0rrrgi297sZ599NkuXLiU5OZmSJUty11138e9//5tLL72UaScoUitTpkxaf5BQixcv5qqrruLo0aNUrVqVmJgYli1bRt/AOE7Dhw/nhRdeyPKcu3fvJikpidq1a0f2I3MgP+tI2gKJgWlzEZGRQAIQGgwSgA/UhqicIyKVRKQ20CCMYzPZv/QnvmvQO9P6RptnsLZkM6651ruyO+dO7Oabb87QL+RYP/zwQ9r7s846i44dO5KSknLcY44nMTGRJk2asGTJEuLi4gBYv349sbGxHDlyhB49emSqrwmqXLkyM2bMOKnvPVn5GUjqAhtDPm/Cch0n2qdumMcCICL9gH4ALShN3S1zM+2TJGXZ3fkGTvJv7JwrZqpUqRLR/rfddluOvu/dd98FoHXr1rRu3RqADz/8ELAOiTcXsGlc8zOQZPX4f+zg+NntE86xtlJ1CDAEID4+XhvMn59lYhpkl0rnnHMRyc9AsgkIncS2HrAlzH1Kh3Gsc865KMjPVlvzgMYi0lBESgO9gM+P2edz4OZA663zgD2qujXMY51zRUhezebnTG5e33zLkahqsojcBUwGSgBDVXW5iNwR2D4YmAh0BRKBg8Ctxzs2v9LunMtfZcuWZefOnVStWrXQzo1ekKkqO3fuzLZDY6SkKEf9+Ph4nZ9NHYlzruA6evQomzZtytBL3OWusmXLUq9evUydGkVkgarGR3Ku4jlEinOuQCtVqlS+DvHhcqZ4DpHinHMu13ggcc45lyMeSJxzzuVIka5sF5F9QP4Nyl+wVQN+jXYiCgC/Dun8WqTza5GuqapGNJxtUa9sXx1p64OiSkTm+7Xw6xDKr0U6vxbpRCTipq5etOWccy5HPJA455zLkaIeSIZEOwEFiF8L49chnV+LdH4t0kV8LYp0Zbtzzrm8V9RzJM455/KYBxLnnHM5UiQDiYh0FpHVIpIoIo9EOz35SUSGish2EVkWsq6KiHwlImsCr5Wjmcb8IiL1RWSqiKwUkeUick9gfbG7HiJSVkTmisgPgWvxTGB9sbsWACJSQkQWicgXgc/F8joAiMh6EVkqIouDTX8jvR5FLpCISAlgENAFaA5cLyLNo5uqfPUe0PmYdY8A36hqY+CbwOfiIBm4X1XjgPOA/oF/C8XxeiQBnVT1TKA10Dkw509xvBYA9wArQz4X1+sQ1FFVW4f0pYnoehS5QAK0BRJVdZ2qHgFGAglRTlO+UdUZwK5jVicA7wfevw/0yM80RYuqblXVhYH3+7AbR12K4fVQsz/wsVRgUYrhtRCRekA34J2Q1cXuOpxARNejKAaSusDGkM+bAuuKs5qBmSYJvNaIcnrynYg0AM4CvqeYXo9Acc5iYDvwlaoW12vxKvAQkBqyrjhehyAFpojIAhHpF1gX0fUoikOkZDWdmrdxLsZE5FTgU+BeVd1bXGfcU9UUoLWIVALGiEiLKCcp34nIFcB2VV0gIh2inJyC4kJV3SIiNYCvRGRVpCcoijmSTUD9kM/1gC1RSktB8YuI1AYIvG6PcnryjYiUwoLIMFX9LLC62F4PAFX9DZiG1aUVt2txIdBdRNZjxd6dROQjit91SKOqWwKv24ExWPVARNejKAaSeUBjEWkoIqWBXsDnUU5TtH0O9Am87wOMi2Ja8o1Y1uNdYKWq/jtkU7G7HiJSPZATQUTKAZcCqyhm10JVH1XVeqraALs3fKuqN1LMrkOQiJQXkQrB98BlwDIivB5Fsme7iHTFykFLAENV9fnopij/iMgIoAM2LPYvwFPAWOBjIBb4GbhGVY+tkC9yROQiYCawlPTy8MewepJidT1EpBVWaVoCe4D8WFWfFZGqFLNrERQo2npAVa8ortdBRBphuRCwqo7hqvp8pNejSAYS55xz+acoFm0555zLRx5InHPO5YgHEueccznigcQ551yOeCBxzjmXIx5InHPO5YgHElesiUjVwPDZi0Vkm4hsDvlcWkRm59H31hOR67JY30BEDgXGxMrpd5QL/I4jIlItp+dzLjtFcawt58KmqjuxYdURkaeB/ar6r5BdLsijr74Em+ZgVBbb1qpq65x+gaoewsbWWp/Tczl3PJ4jce44RGR/IJewSkTeEZFlIjJMRC4Vke8CE/+0Ddn/xsAEUotF5K3A/DjHnvMi4N9Az8B+DY/z/Sf87sAwFxMCk1Ytyyqn41xe8kDiXHjOAAYCrYBmwA3ARcAD2LAriEgccB02mmprIAXofeyJVHUWNiZcQmAyoZ9y+N2dgS2qeqaqtgAm5eiXOhchL9pyLjw/qepSABFZjs0epyKyFGgQ2OcS4GxgXmCo+nJkP2pqU2B1Ln33UuBfIvIP4AtVnRnpj3MuJzyQOBeepJD3qSGfU0n/fyTA+6r66PFOFBgQb4+qHs2N71bVH0XkbKAr8IKITFHVZ8M8t3M55kVbzuWeb7B6jxoAIlJFRE7PYr+G5OIcOSJSBzioqh8B/wLa5Na5nQuH50icyyWqukJEHsemLY0BjgL9gQ3H7LoKqCYiy4B+qprTJsYtgX+KSGrgO+/M4fmci4gPI+9cARKYW/6LQKV5bp1zPRCvqr/m1jmdC+VFW84VLClAxdzskAiUIn1iL+dynedInHPO5YjnSJxzzuWIBxLnnHM54oHEOedcjnggcc45lyMeSJxzzuWIBxLnnHM54oHEOedcjnggcc45lyP/D1GHxU+FguyvAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -461,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -473,7 +482,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -513,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -525,7 +534,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -571,12 +580,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -608,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -629,7 +638,7 @@ " nt, nn = V.shape\n", " acV = np.zeros((nlags+1, nn))\n", " for c in range(V.shape[1]):\n", - " acV[:, c] = acf(V[:, c], unbiased=True, nlags=1000, fft=True)\n", + " acV[:, c] = acf(V[:, c], adjusted=True, nlags=1000, fft=True)\n", " #fftconvolve(V[:, c], V[::-1, c], mode='full') / V[:, c].std()**2\n", " acV = acV.mean(axis=1)\n", "\n", @@ -642,7 +651,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -653,12 +662,12 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -699,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -710,12 +719,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -738,7 +747,7 @@ "plt.ylabel(r'$\\langle V(t)V(t+\\tau)\\rangle$');" ] }, - { + { "cell_type": "markdown", "metadata": {}, "source": [ @@ -755,7 +764,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -769,9 +778,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.9.12" } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/models/noise_generator.h b/models/noise_generator.h index 328f1eb1f3..fa4b39e7b2 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -49,39 +49,36 @@ Generate a Gaussian white noise current Description +++++++++++ -This device can be used to inject a Gaussian "white" noise current into a node. +The `noise_generator` can be used to inject a Gaussian "white" noise current into a node. -The current is not really white, but a piecewise constant current with -Gaussian distributed amplitude. The current changes at intervals of -dt. dt must be a multiple of the simulation step size, the default is -10 times the simulation resolution (equating to 1.0 ms, corresponding -to a 1 kHz cut-off). - -Additionally a second sinusodial modulated term can be added to the standard -deviation of the noise. - -The current generated is given by +The current is not truly white, but a piecewise constant current with a Gaussian distributed +amplitude with mean :math:`\mu` and standard deviation :math:`\sigma`. The current changes at +a user-defined interval :math:`\delta` and is given by .. math:: - I(t) = mean + std \cdot N_j \text{ for } t_0 + j dt \leq t < t_0 + (j-1) dt + I(t) = I(t) = \mu + N_j \sigma + \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;, + +where :math:`N_j` are Gaussian random numbers with unit standard deviation and :math:`t_0` is +the device onset time. -where :math:`N_j` are Gaussian random numbers with unit standard deviation and -:math:`t_0` is the device onset time. -If the modulation is added the current is given by +Additionally a sinusodially modulated term can be added to the standard +deviation of the noise: .. math:: - I(t) = mean + \sqrt(std^2 + std_{mod}^2 \cdot \sin(\omega \cdot t + phase)) \cdot N_j \\ - \text{ for } t_0 + j dt \leq t < t_0 + (j-1) dt + I(t) = \mu + N_j \sqrt{\sigma^2 + \sigma_{\text{mod}}^2 \sin(\omega t + \phi)} + \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;. + +All targets receive different currents, but the currents for all +targets change at the same points in time. The interval between +changes, :math:`\Delta`, must be a multiple of the time step. -For a detailed discussion of the properties of the noise generator, please see +For a detailed discussion of the properties of the noise generator, please see the `noise_generator <../model_details/noise_generator.ipynb>`_ notebook included in the NEST source code. -All targets receive different currents, but the currents for all -targets change at the same points in time. The interval between -changes, ``dt``, must be a multiple of the time step. The effect of this noise current on a neuron depends on ``dt``. Consider the membrane potential fluctuations evoked when a noise current is @@ -129,6 +126,9 @@ phase frequency The frequency of the sine modulation +.. note:: + + Setting parameters from a stimulation backend ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From b72303167470cecc56c450912883adce1d850671 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Tue, 21 Jun 2022 16:37:40 +0200 Subject: [PATCH 014/150] add note about PYNEST_QUIET in docstring --- pynest/nest/lib/hl_api_info.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index ba26a83e06..0419374af5 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -200,6 +200,11 @@ def set_verbosity(level): - M_ERROR=30, display error messages and above - M_FATAL=40, display failure messages and above + .. note:: + + If the environment variable PYNEST_QUIET is set, NEST will not print + welcome text containing the version and other information. + Parameters ---------- level : str, default: 'M_INFO' From 90e4aa8080dc205a310a4bb831f793712f9218c4 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Mon, 15 Aug 2022 23:55:08 +0200 Subject: [PATCH 015/150] Revised comments for noise_generator. --- models/noise_generator.h | 41 +++++++++++++++++----------------------- 1 file changed, 17 insertions(+), 24 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index fa4b39e7b2..e53a61ea45 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -57,8 +57,7 @@ a user-defined interval :math:`\delta` and is given by .. math:: - I(t) = I(t) = \mu + N_j \sigma - \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;, + I(t) = \mu + N_j \sigma \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;, where :math:`N_j` are Gaussian random numbers with unit standard deviation and :math:`t_0` is the device onset time. @@ -72,39 +71,35 @@ deviation of the noise: \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;. All targets receive different currents, but the currents for all -targets change at the same points in time. The interval between -changes, :math:`\Delta`, must be a multiple of the time step. +targets change at the same points in time. The interval :math:`\delta` between +changes must be a multiple of the time step. For a detailed discussion of the properties of the noise generator, please see the `noise_generator <../model_details/noise_generator.ipynb>`_ notebook included in the NEST source code. +.. note:: -The effect of this noise current on a neuron depends on ``dt``. Consider -the membrane potential fluctuations evoked when a noise current is -injected into a neuron. The standard deviation of these fluctuations -across an ensemble will increase with ``dt`` for a given value of ``std``. -For the leaky integrate-and-fire neuron with time constant ``tau_m`` and -capacity ``C_m``, membrane potential fluctuations Sigma at time -:math:`t_j+delay` are given by + The effect of the noise current on a neuron depends on the switching interval :math:`\delta`. + For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capacitance + :math:`C_m`, the variance of the membrane potential is given by -.. math:: + .. math:: - \Sigma = std \cdot \tau_m / C_m \cdot \sqrt( (1-x) / (1+x) ) \\ - \text{where } x = exp(-dt/\tau_m) + \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} -for large :math:`t_j`. In the white noise limit, :math:`dt \rightarrow 0`, one has -.. math:: + for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../model_details/noise_generator.ipynb>`_ + notebook included in the NEST source code. - \Sigma \rightarrow std / C_m * \sqrt(dt \cdot \tau / 2). +.. admonition:: Recording the generated current -To obtain comparable results for different values of dt, you must adapt std. + You can use a `multimeter` to record the average current sent to all targets for each time step, provided you + are simulating using a single thread (multiple MPI processes with one thread each also work). In this case, + the recording `interval` of the `multimeter` should be the simulation resolution to avoid confusing effects + due to offset or "gliding" between the recording times of the `multimeter` and the switching times of the + `noise_generator`. In multi-threaded mode, recording is prohibited for technical reasons. -As the noise generator provides a different current for each of its targets, -the current recorded represents the instantaneous average of all the -currents computed. When there exists only a single target, this would be -equivalent to the actual current provided to that target. .. include:: ../models/stimulation_device.rst @@ -126,8 +121,6 @@ phase frequency The frequency of the sine modulation -.. note:: - Setting parameters from a stimulation backend ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From 578f8f1ef45a0647906121178389987f4ba9cae5 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 16 Aug 2022 14:19:05 +0200 Subject: [PATCH 016/150] Improving comment structure. --- models/noise_generator.h | 41 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 23 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index e53a61ea45..20f7105e40 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -70,27 +70,21 @@ deviation of the noise: I(t) = \mu + N_j \sqrt{\sigma^2 + \sigma_{\text{mod}}^2 \sin(\omega t + \phi)} \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;. -All targets receive different currents, but the currents for all -targets change at the same points in time. The interval :math:`\delta` between -changes must be a multiple of the time step. - -For a detailed discussion of the properties of the noise generator, please see the -`noise_generator <../model_details/noise_generator.ipynb>`_ -notebook included in the NEST source code. + The effect of the noise current on a neuron depends on the switching interval :math:`\delta`. + For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capacitance + :math:`C_m`, the variance of the membrane potential is given by -.. note:: + .. math:: - The effect of the noise current on a neuron depends on the switching interval :math:`\delta`. - For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capacitance - :math:`C_m`, the variance of the membrane potential is given by + \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} - .. math:: - \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} + for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../neurons/model_details/noise_generator.ipynb>`_ + notebook included in the NEST source code. - - for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../model_details/noise_generator.ipynb>`_ - notebook included in the NEST source code. +All targets of a noise generator receive different currents, but the currents for all +targets change at the same points in time. The interval :math:`\delta` between +changes must be a multiple of the time step. .. admonition:: Recording the generated current @@ -104,22 +98,23 @@ notebook included in the NEST source code. .. include:: ../models/stimulation_device.rst mean - The mean value of the noise current (pA) + The mean value :math:`\mu` of the noise current (pA) std - The standard deviation of noise current (pA) + The standard deviation :math:`\sigma` of the noise current (pA) dt - The interval between changes in current (ms; default: 10 * resolution) + The interval :math:`\delta` between changes in current (ms; default: 10 * resolution) std_mod - The modulated standard deviation of noise current (pA) + The modulation :math:`\sigma_{\text{mod}}` of the standard deviation of the noise current (pA) + +frequency + The frequency of the sine modulation (Hz) phase - The phase of sine modulation (0-360 deg) + The phase of sine modulation (0–360 deg) -frequency - The frequency of the sine modulation Setting parameters from a stimulation backend From bfc834dc60b7e69e9f91de911dca2b26dad502bd Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 16 Aug 2022 14:22:14 +0200 Subject: [PATCH 017/150] Fixed indent. --- models/noise_generator.h | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index 20f7105e40..4d44ae0cc0 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -70,17 +70,16 @@ deviation of the noise: I(t) = \mu + N_j \sqrt{\sigma^2 + \sigma_{\text{mod}}^2 \sin(\omega t + \phi)} \quad \text{for} \quad t_0 + j \delta < t \leq t_0 + (j+1) \delta \;. - The effect of the noise current on a neuron depends on the switching interval :math:`\delta`. - For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capacitance - :math:`C_m`, the variance of the membrane potential is given by +The effect of the noise current on a neuron depends on the switching interval :math:`\delta`. +For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capacitance +:math:`C_m`, the variance of the membrane potential is given by - .. math:: - - \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} +.. math:: + \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} - for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../neurons/model_details/noise_generator.ipynb>`_ - notebook included in the NEST source code. +for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../neurons/model_details/noise_generator.ipynb>`_ +notebook included in the NEST source code. All targets of a noise generator receive different currents, but the currents for all targets change at the same points in time. The interval :math:`\delta` between From c9c910758699d07df593e9e133eb90362707688e Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 16 Aug 2022 14:25:32 +0200 Subject: [PATCH 018/150] Minimal touch-up --- models/noise_generator.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index 4d44ae0cc0..b1e6f1d81e 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -78,8 +78,8 @@ For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capa \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} -for :math:`\delta \ll \tau_m`. For details, see the `noise_generator <../neurons/model_details/noise_generator.ipynb>`_ -notebook included in the NEST source code. +for :math:`\delta \ll \tau_m`. For details, see the `noise_generator notebook <../neurons/model_details/noise_generator.ipynb>`_ +included in the NEST source code. All targets of a noise generator receive different currents, but the currents for all targets change at the same points in time. The interval :math:`\delta` between From 02229c4202ac003dc3b4293212fe38335bd389ee Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 16 Aug 2022 14:35:46 +0200 Subject: [PATCH 019/150] Formatting fixes. --- models/noise_generator.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index b1e6f1d81e..3a420689ab 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -76,10 +76,10 @@ For a leaky integrate-and-fire neuron with time constant :math:`\tau_m` and capa .. math:: - \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} + \Sigma^2 = \frac{\delta \tau_m \sigma^2}{2 C_m^2} -for :math:`\delta \ll \tau_m`. For details, see the `noise_generator notebook <../neurons/model_details/noise_generator.ipynb>`_ -included in the NEST source code. +for :math:`\delta \ll \tau_m`. For details, see the `noise_generator notebook +<../neurons/model_details/noise_generator.ipynb>`_ included in the NEST source code. All targets of a noise generator receive different currents, but the currents for all targets change at the same points in time. The interval :math:`\delta` between From 4ffd504d8c187b63fd8558f66db95e2b546a2ba9 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 16 Aug 2022 15:27:36 +0200 Subject: [PATCH 020/150] Manually add clang-format fix from #2449. --- .github/workflows/nestbuildmatrix.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index 8976aabd21..f0178910e7 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -67,7 +67,7 @@ jobs: - name: "Install Python dependencies" run: | python -m pip install --upgrade pip setuptools - python -m pip install clang-format==13.0 + python -m pip install --force-reinstall clang-format==13.0 python -c "import setuptools; print('package location:', setuptools.__file__)" python -m pip install --force-reinstall --upgrade scipy 'junitparser>=2' numpy pytest pytest-timeout pytest-xdist mpi4py cython matplotlib terminaltables pandoc python -c "import pytest; print('package location:', pytest.__file__)" From 5d2d02cd7286b1660ca0db290e7fc032884a60a9 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 17 Aug 2022 13:31:24 +0200 Subject: [PATCH 021/150] Corrected link to multimeter in doc text --- models/noise_generator.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index 3a420689ab..4dd56ba7d4 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -87,11 +87,11 @@ changes must be a multiple of the time step. .. admonition:: Recording the generated current - You can use a `multimeter` to record the average current sent to all targets for each time step, provided you + You can use a :doc:`multimeter ` to record the average current sent to all targets for each time step, provided you are simulating using a single thread (multiple MPI processes with one thread each also work). In this case, - the recording `interval` of the `multimeter` should be the simulation resolution to avoid confusing effects - due to offset or "gliding" between the recording times of the `multimeter` and the switching times of the - `noise_generator`. In multi-threaded mode, recording is prohibited for technical reasons. + the recording interval of the should be the simulation resolution to avoid confusing effects + due to offset or drift between the recording times of the multimeter and the switching times of the + noise generator. In multi-threaded mode, recording is prohibited for technical reasons. .. include:: ../models/stimulation_device.rst From 65bf6899965895db6178d0f2bf349238ed508ad5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Thu, 18 Aug 2022 18:04:52 +0200 Subject: [PATCH 022/150] Set returns_int_only_ in constructor --- nestkernel/parameter.h | 1 + 1 file changed, 1 insertion(+) diff --git a/nestkernel/parameter.h b/nestkernel/parameter.h index 84b2f4fd98..a01b3f071d 100644 --- a/nestkernel/parameter.h +++ b/nestkernel/parameter.h @@ -136,6 +136,7 @@ class ConstantParameter : public Parameter ConstantParameter( double value ) : value_( value ) { + returns_int_only_ = value_is_integer_( value_ ); } /** From 2401176af73dc6a4b24b27ec73a7953b459417a8 Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 21 Aug 2022 12:39:55 +0200 Subject: [PATCH 023/150] UnitTest for checking copied models --- testsuite/pytests/test_copied_model.py | 79 ++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 testsuite/pytests/test_copied_model.py diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copied_model.py new file mode 100644 index 0000000000..c405dc74e1 --- /dev/null +++ b/testsuite/pytests/test_copied_model.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +# +# test_copied_model.py +# +# 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 . + +""" +Assert that all existing neuronal models are copied correctly and new Ids are correctly assigned to the new copied models. +""" + +import unittest +import nest + + +@nest.ll_api.check_stack +class CopyModelTestCase(unittest.TestCase): + """nest.CopyModel Test""" + + def check_copied_model(self, original_model, is_synapse=False): + """Test if the new copied neuron or synapse model has been assigned a correct ID and if the new name is correctly stored in the new instances.""" + + keys_to_query = ["model", "model_id"] + if is_synapse: + keys_to_query = ["synapse_model", "synapse_modelid"] + + new_name = f"{original_model}_copy" + current_model_id = nest.GetDefaults(original_model)[keys_to_query[1]] + + nest.CopyModel(original_model, new_name) + copied_model_new_id = nest.GetDefaults(new_name)[keys_to_query[1]] + + self.assertGreater(copied_model_new_id, current_model_id) + + if not is_synapse: + original_model_instance = nest.Create(original_model) + copied_model_instance = nest.Create(new_name) + + original_model_instance_info = original_model_instance.get(keys_to_query) + + copied_model_instance_info = copied_model_instance.get(keys_to_query) + + self.assertNotEqual(copied_model_instance_info[keys_to_query[0]], + original_model_instance_info[keys_to_query[0]]) + + self.assertNotEqual(original_model_instance_info[keys_to_query[0]], "UnknownNode") + + self.assertGreater(copied_model_instance_info[keys_to_query[1]], original_model_instance_info[keys_to_query[1]]) + + def check_copy_model_correctness(self, models, synapse=False): + """Iterates over all registered and available model and checks the correctness of the nest.CopyModel on each model.""" + + for model in models: + self.check_copied_model(model, is_synapse=synapse) + + def test_builtin_neuron_models(self): + """Checks the correctness of the nest.CopyModel on neurons only""" + + neurons = nest.node_models + self.check_copy_model_correctness(neurons, synapse=False) + + def test_builtin_synapse_models(self): + """Checks the correctness of the nest.CopyModel on synapses only""" + synapses = nest.synapse_models + self.check_copy_model_correctness(synapses, synapse=True) From 2231f3cccb3e0262129502a10af9323658c04a3c Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 21 Aug 2022 12:55:37 +0200 Subject: [PATCH 024/150] Fix too long lines --- testsuite/pytests/test_copied_model.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copied_model.py index c405dc74e1..9017ef01b1 100644 --- a/testsuite/pytests/test_copied_model.py +++ b/testsuite/pytests/test_copied_model.py @@ -20,7 +20,8 @@ # along with NEST. If not, see . """ -Assert that all existing neuronal models are copied correctly and new Ids are correctly assigned to the new copied models. +Assert that all existing neuronal models are copied correctly +and new Ids are correctly assigned to the new copied models. """ import unittest @@ -32,7 +33,8 @@ class CopyModelTestCase(unittest.TestCase): """nest.CopyModel Test""" def check_copied_model(self, original_model, is_synapse=False): - """Test if the new copied neuron or synapse model has been assigned a correct ID and if the new name is correctly stored in the new instances.""" + """Test if the new copied neuron or synapse model has been assigned a correct ID + and if the new name is correctly stored in the new instances.""" keys_to_query = ["model", "model_id"] if is_synapse: @@ -62,7 +64,8 @@ def check_copied_model(self, original_model, is_synapse=False): self.assertGreater(copied_model_instance_info[keys_to_query[1]], original_model_instance_info[keys_to_query[1]]) def check_copy_model_correctness(self, models, synapse=False): - """Iterates over all registered and available model and checks the correctness of the nest.CopyModel on each model.""" + """Iterates over all registered and available model + and checks the correctness of the nest.CopyModel on each model.""" for model in models: self.check_copied_model(model, is_synapse=synapse) From 931e523a65bd17350a7628cccc42a0de24f98b5f Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 21 Aug 2022 13:05:57 +0200 Subject: [PATCH 025/150] Make variable name shorter --- testsuite/pytests/test_copied_model.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copied_model.py index 9017ef01b1..f96581c10d 100644 --- a/testsuite/pytests/test_copied_model.py +++ b/testsuite/pytests/test_copied_model.py @@ -52,16 +52,16 @@ def check_copied_model(self, original_model, is_synapse=False): original_model_instance = nest.Create(original_model) copied_model_instance = nest.Create(new_name) - original_model_instance_info = original_model_instance.get(keys_to_query) + original_model_info = original_model_instance.get(keys_to_query) - copied_model_instance_info = copied_model_instance.get(keys_to_query) + copied_model_info = copied_model_instance.get(keys_to_query) - self.assertNotEqual(copied_model_instance_info[keys_to_query[0]], - original_model_instance_info[keys_to_query[0]]) + self.assertNotEqual(copied_model_info[keys_to_query[0]], + original_model_info[keys_to_query[0]]) - self.assertNotEqual(original_model_instance_info[keys_to_query[0]], "UnknownNode") + self.assertNotEqual(original_model_info[keys_to_query[0]], "UnknownNode") - self.assertGreater(copied_model_instance_info[keys_to_query[1]], original_model_instance_info[keys_to_query[1]]) + self.assertGreater(copied_model_info[keys_to_query[1]], original_model_info[keys_to_query[1]]) def check_copy_model_correctness(self, models, synapse=False): """Iterates over all registered and available model From 31c2cc06918b3568ebf4ce5544770e0b1137c350 Mon Sep 17 00:00:00 2001 From: "ayssar:ubuntu_pc" Date: Sun, 21 Aug 2022 21:05:25 +0200 Subject: [PATCH 026/150] Remove superfluous assertions --- nestkernel/model_manager.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 63145a5187..1bb0fb811e 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -259,9 +259,6 @@ ModelManager::copy_node_model_( index old_id, Name new_name ) const thread t = kernel().vp_manager.get_thread_id(); const int model_id = new_model->get_model_id(); - assert( model_id > 0 ); - assert( ( ( index ) model_id ) > old_id ); - proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); } From d99a3b529ac4219a6bc60774039373dd4cc0cfe9 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Sun, 21 Aug 2022 22:38:01 +0200 Subject: [PATCH 027/150] Update aeif_models notebook and environment specs to obtain assimulo from conda-forge. --- .../aeif_models_implementation.ipynb | 73 ++++++++++++------- environment.yml | 1 + 2 files changed, 48 insertions(+), 26 deletions(-) diff --git a/doc/htmldoc/neurons/model_details/aeif_models_implementation.ipynb b/doc/htmldoc/neurons/model_details/aeif_models_implementation.ipynb index 8e62614b0d..29ce795e24 100644 --- a/doc/htmldoc/neurons/model_details/aeif_models_implementation.ipynb +++ b/doc/htmldoc/neurons/model_details/aeif_models_implementation.ipynb @@ -74,19 +74,10 @@ "To run this notebook, you need:\n", "\n", "* [numpy](http://www.numpy.org/) and [scipy](http://www.scipy.org/)\n", - "* [assimulo](http://www.jmodelica.org/assimulo)\n", - "* [matplotlib](http://matplotlib.org/)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Install assimulo package in the current Jupyter kernel\n", - "import sys\n", - "!{sys.executable} -m pip install assimulo" + "* [assimulo](http://www.jmodelica.org/assimulo) (from conda-forge; the version on PyPi is outdated)\n", + "* [matplotlib](http://matplotlib.org/)\n", + "\n", + "If you have created a Conda environment from NEST's `environment.yml` file, all requirements are satisfied." ] }, { @@ -536,7 +527,15 @@ " Starter : classical\n", "\n", "Simulation interval : 0.0 - 100.0 seconds.\n", - "Elapsed simulation time: 0.07648879801854491 seconds.\n" + "Elapsed simulation time: 0.05795993999999993 seconds.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/5k/0gyqhsf50418tc1x1l1t5lsw0000gn/T/ipykernel_10927/4162922571.py:44: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " t, y = exp_sim.simulate(simtime) #Simulate 10 seconds\n" ] } ], @@ -565,7 +564,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6cAAAF3CAYAAABZvT12AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeXhdVb3/8fc6yUlO5jlpmqQZmqRzOkMHWkoBUQZBBIGLghdREbQiFwe8F/V64SdyQREUZbBFAUVQZJapLdAylKYTbZrOSZt5npMzr98fLVwqLRRps9Pk83qePD37nLVPvt/zEJpP19prG2stIiIiIiIiIk5yOV2AiIiIiIiIiMKpiIiIiIiIOE7hVERERERERByncCoiIiIiIiKOUzgVERERERERxymcioiIiIiIiOMcD6fGmAhjzAZjzDMHjguNMWuMMTuNMX8xxkQ5XaOIiIiIiMjxzBiTZ4xZaYypNMZUGGO+feD5VGPMSwfy10vGmBSnanQ8nALfBirfd/xz4JfW2hKgA/iKI1WJiIiIiIgMH0HgP6y1E4A5wDXGmInAD4DlB/LX8gPHjnA0nBpjcoGzgPsPHBtgMfDXA0P+AJznTHUiIiIiIiLDg7W2wVq7/sDjHvZPEOYA57I/d4HD+cvpmdM7gO8B4QPHaUCntTZ44LiW/R+YiIiIiIiIHAXGmAJgOrAGyLLWNsD+AAtkOlVXpFPf2BhzNtBsrV1njFn07tOHGGoPc/7XgK8dOJwZGxt79IsUERERERE5DvT391tg/fueutdae+8/jzPGxAN/A6611nbvX7w6NDgWToH5wGeNMWcCHiCR/TOpycaYyAOzp7lA/aFOPvBB3wsQFxdn+/r6BqdqERERERGRIcYYM2CtnfURY9zsD6YPW2sfP/B0kzEm21rbYIzJBpqPda2H49iyXmvtDdbaXGttAXAxsMJaeymwErjgwLDLgScdKlFERERERGRYOLC/z++BSmvtL9730lPsz13gcP5y+prTQ/k+cJ0xZhf7r0H9vcP1iIiIiIiIHO/mA18CFhtjNh74OhO4BTjdGLMTOP3AsSOMtYe8pPO4omW9IiIiIiIyEllr8Tf48eR4+q21cU7X80k4ec3pMRUIBKitrcXr9TpdiuM8Hg+5ubm43W6nSxERERERkX+BtZbON5roc7XR6B6gav1WkusfJCK9AdfoQ27Tc9wZtuG0traWhIQECgoKGEo7UA02ay1tbW3U1tZSWFjodDkiIiIiInIIYX+YgeoB+vd00Lapl+aNzXhzl+EftZue0duJiekkOdlP9TOT+ffbtxBhDM88nExPWzx9W/OADqdb+MSG7bLeyspKxo8fP6KD6bustWzbto0JEyY4XYqIiIiIyIjlb/IT6PDjLoqipqaGvcuWEQpvwxXfiCujCZPdAFsnwvdvxYcP10OXEYzupaY9hNebSnxfCbjLSC0+leLiYoqKinj3lprGGC3rHcoUTPfT5yAiIiIicmyFvCF8NT7697bTtzNE8+Zmus0/CKZton3CNoxpJi0yiO2O59MT67DW8sQvC0iYWMtAYxJ9rYn015fi9ecQ/ulWCqYXkF/8MoWFpURHRzvd3qAY1uF0OGppaeHss8/G7/dz5513smDBAqdLEhEREREZtt5daWqMobuyhbb124hYkE99fT2dzzxPhF2HK7GFiLRWyGqCiBBc/SxhLIEbXiZ64evQEqajw0Nvbw62L5cf/egrFBQUkJifxpgx48lfXEhkpKKZPoEhKBQKERERccjXli9fzvjx4/nDH/4wyFWJiIiIiAwvwe4g3n1efM19DLTU0dG4k+62KrxvTsFf48I1djXuxc/TOWYXMfF9xMSEIAc+PzGK9j4/t185nrJzq+lrSqC/Ix5vfTEBUum+fi2jJueQP/ZG8vNLWXhK7mF/v5f/o3B6jNx66614PB6WLFnCd77zHTZt2sSKFStYvnw5y5Yt46GHHjpofEFBAVdccQUvvvgi3/zmN5k9ezbXXHMNLS0txMbGct999+H1evne977HwMAA06ZN48033yQmJsahDkVEREREho6QN0SwPUiwI0igPUCgLUBPfQPtnWvxT2mmN7oG/95mPNUDrOsrZltXNzNDnUy+8GVI6IUs9n8BrQ/+jMbqGNxjKsiOq6eh1o03nEtUaDQxJpdbbl/A6NwisrOzyM0dQ0ZGhi6lOwpGRDi99tpr2bhx41F9z2nTpnHHHXcc9vWFCxdy++23s2TJEsrLy/H5fAQCAVavXn3Ypbgej4fVq1cDcOqpp/K73/2OkpIS1qxZw9VXX82KFSv46U9/Snl5Ob/+9a+Paj8iIiIiIkNNOBCmu6KBUFwjfdFNtFfvpfvZOvxji2lPjiW4pZos1wu4Ynsxcb2Q0LP/6+ffhzVzYM6b8LMfAhAFRI6FYEYsK366gcrWSOzk0cRuHEvQxmMjU4lOHk1iVhE5D87ixNwisrOvGjHXew4FIyKcOmHmzJmsW7eOnp4eoqOjmTFjBuXl5axatYo777zzkOdcdNFFAPT29vLGG29w4YUXvveaz+cblLpFRERERJwQ8oZoKa9kx1vP0v56JMFX80lKacf9+69D5/sGfgae+UURv3p6D/OKsvjhT734eqPw90cTqI8mGMylfmwlgSIvyWNdZOy9jqS0fFJTx5KZWUxW1miePzdeM51D0IgIpx82w3msuN1uCgoKWLZsGfPmzaOsrIyVK1eye/fuw97SJS5u/87P4XCY5OTkoz7bKyIiIiIyFNiwxef3sWXdJtpevANX4k4iC6owae0wC2KqPsuO/tPYO6qXrFc/zUBcMhGpKcTGZhEfn83nv1vEV3+WTUpKCsnJycTExChsDgMjIpw6ZeHChdx2220sXbqUKVOmcN111zFz5syP/MFJTEyksLCQxx57jAsvvBBrLe+88w5Tp04dpMpFRERERD65cDBMz7ZmaqtWUxe9ira2clJbu+isTeDS29cSCoV46dFkAr0e2ivH4A8uJLnwBKZ+//Oc8ZvSA+9yg6M9yOBROD2GFixYwM0338zcuXOJi4vD4/Ec8a1fHn74Yb7xjW9w0003EQgEuPjiiw8ZTq+88kquuuoqZs2adbTLFxERERE5ItZaBmp7aVi3hrptq+lvaMX759OIb4sn8rdXQ+lOooDkZOjtyaSXFH7wgx8wdepU8somUlw8XrvZCubd+/Ycz+Li4mxfX99Bz1VWVh52+exIpM9DRERERI6Gvuo2at5eQ/OoeLZu3Ur6juWkTi7HlVsHUQEAwp0JrP/8jfRm9pH12V0klSaRM+skysrOICUl1eEOhidjTL+1Ns7pOj4JzZyKiIiIiMhB/G1+erf20rCmgcaalwimLKez5B2i45pITvZBJpx7hptub4CfXjyFSTnR9O+dC9GFJI2dRum00zjZP0GzofKxKJyKiIiIiIxA766g3P3q29Suegafbw9E1xGZ3khEXi1cfTfUjMGetxP3p1/CV2doaEkgyj+DJNdk/vLXs5g4ZTq5ubm4XC6Hu5HhQOFURERERGQYstYSaAnQu6OV+h2v0ZGyhTazmVD7PlL8/Tzx1CiWrVrPpVPzufimCqLChkBLMj1NKfStm0jLKRUkFAconPNZJkz+L0759CjtiCvHlMKpiIiIiMhxLNDjpfrZ12jZu5m+3j2EqcMV2wzPfhr36wuhdDvccxUACSFo7XfR2VVAdKqHK664gvFFefh7kxg74STyF5YQGamIIM7Qf3kiIiIiIkOQDVn8TX68tQO0Vq2lnQrak7fR072TpN0DVFdn8Lu1tYRb2/jlH/bCKHADYZ8bX2Mye7M20DA5REypYfSGq8konsbYcfNYuLAUt9vN+U43KPJPFE5FRERERAZZ2B8m1BvCneqmt7eXinv+QF/XboKhBohuISKhHdeWSZilXwEsPH82RPuJBmwC+LLTad/tIzMzk8ITTmDfWh+JOSWMLp5B0eSZpKWlYS7XElw5viicDnGLFi3itttu+8B9TB944AHKy8v59a9/7VBlIiIiIvJ+1lqCHUF8DQP0NzfSXdtE744Eeqp78KY/QShjN11j9wAtpIUt/TUZXPb/aujq6uKlB0cRObMRd8gQaE+gry2Bluh4qia/THRuNKPXXkZSfj7ZRdMpLZ3OqFGjOPtyF993ummRo0jhVERERETkEEIDIQJtAYJtQbxtbXi763Gd0Etr6x7aV1Xjq+9n1+hSmpqamNm/gcTxlZiUDkjuhIgw2Dy46Y8ECGB/8QJRE7cTbg/S2elmoDuPvtZUvvSlReTm5tIeNmRSSF5+Gbnz8/F4PE63LzLoFE6PkVtvvRWPx8OSJUv4zne+w6ZNm1ixYgXLly9n2bJlPPTQQweNX758Oddffz3BYJDZs2fz29/+lujo6IPGLFu2jJ/97GdkZ2dTWlr6gddFRERE5MhZa/H7/WzatInWF58l0r8Rl7sHE9ODK64XE9sPX34AMPC9n8NnnocdB06eBO6iaL55pg9jDP975STyOg3+hjwCwYmEI5KJiB6F6659ZBRlkJl1H1lZeZyUmUlUVJSDXYsMXSMmnG5YtOEjx6SdncaY68e8N37Ul0eR/eVs/K1+Ki6oOGjs9Femf+h7LVy4kNtvv50lS5ZQXl6Oz+cjEAiwevVqFixYcNBYr9fLl7/8ZZYvX05paSmXXXYZv/3tb7n22mvfG9PQ0MCPf/xj1q1bR1JSEqeccgrTp394DSIiIiKyn7WWgX2d7OtZyc6qp/Hv3UxKQjOXfaeLuo5ubr+sjGkXbcffFYO/x4Ov14O/PZaNE5/ClRhFRlcmiasvwGQkk5icR2pqPhnZxTQ0jCU9PV073IocBfopOkZmzpzJunXr6OnpITo6mhkzZlBeXs6qVau48847Dxq7fft2CgsLKS0tBeDyyy/nN7/5zUHhdM2aNSxatIiMjAwALrroInbs2IGIiIiIHMyGLT07Wtj1xks0rnTR91YkCQXleH5wG0SESUiA7uxIuqpKuOrfP8uEeadQWlpEevooUlNTD1qddul/OtiIyAgzYsLpR810ftj4qPSoj32+2+2moKCAZcuWMW/ePMrKyli5ciW7d+9mwoQJB4211h7Re+qmxyIiIiIHs9bi8/l4Z/mrtK/5AyauCndODa7R9VBk8fzpBlp2jaM+KkTaKwsx2eMpmXUO8+efjtvt5nNONyAi7xkx4dQJCxcu5LbbbmPp0qVMmTKF6667jpkzZ34gZI4fP57q6mp27dpFcXExDz74ICeffPJBY0488US+/e1v09bWRmJiIo899hhTp04dzHZEREREHBP2hemsqGVf02vU29X0tG8kvbuLzW9lcf2fVlOSksLdf2nDX59OR10m3l2TiE6ZQP5PTuGiZxbg8VzudAsi8hEUTo+hBQsWcPPNNzN37lzi4uLweDwfuN4UwOPxsGzZMi688ML3NkS66qqrDhqTnZ3NT37yE+bOnUt2djYzZswgFAoNVisiIiIigyLUF6JjSxXVG16lo3ED3h0xhJ85iYT+GFzPnwkxIWKBcBh6OscQjHVzww03MG3qVHJySyheNAWXy+V0GyLyLzBHuqR0KIuLi7N9fX0HPVdZWfmB5bMjmT4PERERGUqstTSvqaB2VwX74qLYvn070+wTeCZWQlL3e+P635xKxf9cSmB0gJwLNxI3Jo/c6SczadIpJCQkONiByNBijOm31sY5XccnoZlTERERETkmgr1BerY30rimh4a1DXjjHseMWUfXmK0kJ/fg8Vj8oWzOP78BgHuunUpCoIRAaDSejPHkTZvP9KsXceYNSQ53IiKDQeFURERERP5loYEQLo+L9vZ2Kh/9K/0Nq7HRNUSmNhIxugHcAbjmWVy4MN/diitnFx0d0NJSTLx/IokJU1m79hxKS0tJTEx0uh0RcZDCqYiIiIgclg1ZfLU+enb0sG/zW3T2vEpncSVeqoj395CU1MdXrolkT2MLd10xjclf2oi/OZmehlT6N5YQDI8i+J87KZhXzJSyP5KTk6M7EIjIISmcioiIiIxgNmT339bOBXvf2kDNq8/g7a/CRtYTkdRMREYL5r9ugupCOGclEdf9kpQQNLdApzeVgbpCvvCFWWQVTiAvP4OMjPEUz5180L1CRUSOhMKpiIiIyDBlrcXf4se3b4DOHd00bttGj3mW3rwq+uOqcQc6SIsI88RDefxuxQYunT6Wy26pJAoIdsQz0JTCwL5UaqZsIGJBF5nTx5HLI5SMn8OiU/Le2xX3YmfbFJEjYIxZCpwNNFtrJx947ifAV4GWA8N+aK19zpkKFU5FREREjltBfz+Ny7cyEBuiKy6Cpq27idzxOMbdjiuhjYjUdkxmM9z7NXjyPCisJWLpnSSEDN5WS9dADKH2sSTkZnPttSdTkJ1Bb2sUBePnUnTCJGJjY51uUUSOngeAXwN//Kfnf2mtvW3wy/kghVMRERGRIcJaS9e6JgbaGuhq2kdXy14Gehvx7k3Gu7YUugLEX3cTgYxGbEorsbFhiIF3HprMt+/fQk58Ig8+0UOwI4GB9ni8zYl4q6fQldmPWVJBxuQURkf+nTFF01h4ci6Rkft/FbzI4b5F5Niz1r5mjClwuo4Po3AqIiIiMggC3QEqn6ykee9jBDy76c2vJRRqJ7XZRVfNKH67LkhbWxt33LwbE98HY9j/BZgXT6ZtSxodpp1i00NPYxztrXEYk05SXxEp08bz5JM3k5WVRXZ2FllZ2brmU2TkiTTGlL/v+F5r7b1HcN43jTGXAeXAf1hrO45NeR9N4fQYufXWW/F4PCxZsoTvfOc7bNq0iRUrVrB8+XKWLVvGQw89dND4goICLr/8cp5++mkCgQCPPfYY48ePp6+vj29961ts3ryZYDDIT37yE84991zOPPNMbrnlFsrKypg+fTqf+9zn+NGPfsSNN95Ifn4+V155pUOdi4iISDgYpuHtd9j++pP096zH1Q7Rv1lCBBFE/v5hIouqCPVCVxd0u7No9LsIBBIoLCxk++ocImNjiIpPJzZ9NKmjC8m9dAInfLeY5ORkjPmu0+2JyNAUtNbO+pjn/Bb4H8Ae+PN24IqjXdiRGjHhdMOGRR94LjPzC+TkXE0o1M8775z5gddHjfoy2dlfxu9vpaLigoNemz79lQ/9fgsXLuT2229nyZIllJeX4/P5CAQCrF69mgULFhzynPT0dNavX8/dd9/Nbbfdxv3338/NN9/M4sWLWbp0KZ2dnZxwwgmcdtppLFy4kFWrVlFQUEBkZCSvv/46AKtXr+aLX/zikX0oIiIi8onZkKWloprdfY1s2LCBzKrnSDvxLUx6G67ZEBeIpG9zMVtnbCVjQQa5mbeTObqU9PRskpOT39tU6FsO9yEiI4+1tundx8aY+4BnHCxn5ITTwTZz5kzWrVtHT08P0dHRzJgxg/LyclatWsWdd955yHPOP//89859/PHHAXjxxRd56qmnuO22/dcoe71e9u3bx4IFC7jzzjspLCzkrLPO4qWXXqK/v5/q6mrGjRs3OE2KiIiMMMHeIHVvvMOejU/TlP06fruVjNhuPCl9fPYsF72+IDdfMp3S7WMIbDmFtJKTmPnpi0g7fRRc53T1IiIHM8ZkW2sbDhx+DtjiZD0jJpx+2ExnRETsh74eFZX+kTOl/8ztdlNQUMCyZcuYN28eZWVlrFy5kt27dzNhwoRDnvPutSEREREEg0Fg/8YIf/vb3z4QOP1+P+Xl5RQVFXH66afT2trKfffdx8yZMz9WnSIiIvJB1lr6qjrY+fpLtFS9SdBuw7/0AhL3FeH6/OOYb/6GjBA0NETSUJdP3NYyHnrwQmbMOYnc3FyMMU63ICJyEGPMn4FFQLoxphb4MbDIGDON/ct6q4GvO1YgIyicOmHhwoXcdtttLF26lClTpnDdddcxc+bMj/UX1hlnnMFdd93FXXfdhTGGDRs2MH36dKKiosjLy+PRRx/lxhtvpKWlheuvv57rr7/+GHYkIiIy/Ph7+tn5/HJqg/1srqshVLGJ2aeuwJXdCHlhovIgss9DzXNF7EhoJzU9l/ymXzPl5HM49dQxTpcvInJErLWXHOLp3w96IR9C4fQYWrBgATfffDNz584lLi4Oj8dz2OtND+fGG2/k2muvpaysDGstBQUFPPPMM++9//Lly4mNjWXBggXU1tZ+7PcXEREZKXxNPhreaKD6jc0MxD5E36ithNN2k5Y2QEQGvPbLyfy/p7awePJ4Siem4a+agjthPDnTTmbSyaexeE2C0y2IiAxrxlrrdA2fWFxcnO3r6zvoucrKysMunx2J9HmIiMhI4ff62PLI32it2UjAt5uI+DqishpxvXIK/PFyiOvFPnkuPY1x1Ha5seF8MvtPIGPSYqbMOZW0tDSnWxAR+diMMf3W2jin6/gkNHMqIiIixxVrLf7mAVr2baY29AaNjWtxb22kvSmaW17ex64dO3n+yUiiCgZwh1z4G9PobkqnM85P8Kpd5MzPYcLYSvIXl+jaUBGRIUThVERERIYcay2++n7qN22gfkc5ve07CLT68T52BvEd8cTc800YuweA5GTwT4rB9pVQUlLCOeecQ+uuCEZPmMz4GYtJS8tyuBsRETkSCqciIiLiiHAgTNj0U1Ozhn3L36J3Xx1vhlPZvXs3F43dS/KityE2BNPAA0TWZbF36TSqMqtIXzeb6Ka5JE6ZzNixJ1M8byZR50ZxmdNNiYjIv2xYh1NrrZbrsP9zEBERGWyhvhC9Vc3Ub91Ia00F/d1V9D5zMuEGQ8JpzxJ93lOY1I79g4shttDFbZ8x5OTlMyuhkJzXF2Gic0nIHkfOlNkUz57DaZfGO9uUiIgcM8M2nHo8Htra2khLSxvRAdVaS1tbGx6Px+lSRERkGAn7w/ga+vHFNNHYvpnGDRvxbt3HZpPD9voGZoUbGX/ea5DYA5lAJkQDXXdPpLnD0t3pI2HrWNoTPcSllJCZMo2Cknn09E3F7XY73Z6IiDhg2O7WGwgEqK2txev1OlTV0OHxeMjNzdVf9iIicsR669qoeuV1Oht3MtBdSzDYhHG34nv8bNzbxxI37234r5sgInzQeTdfk83mtjAXzxnPnBk+QqQRGZtDQnYJ2eOnUjh2FsnJKQ51JSIyfGm33iHM7XZTWFjodBkiIiKOstYS6g7hbeqlt76WzuoBuvdYeptrCWQ8x0BOPf2J9bj83WT4Iln+jxzuf6OCxTkpXPXLHZADUez/CnbGU/diEa1J/XjoImP1KfhTEvBk5JKeNoncvBk8VT6FmJgYp9sWEZHj0LCdORURERmJBvoGWL9xPeteXsHYyGeJya3HldYO8Qf+nrz7G/DYFyCnFh76EiG/i7bOMN6+aBK7xrB+YzHNnjEUZKZSnNpDfFY+6YXjyckvIzMzh4iICGcbFBGRQxoOM6cKpyIiIsepkC/Evoo32Nb0OC3Nr5Id7GBPeQpX/W4DMZGRPPlAKn0NGQz0JxIKJ2LcyYTNROLSJpNalER6djyZmYWkpaUpdIqIHOcUTocIhVMRERnuQr4Qe157g6rXN9DyjzTMTsOoX9yAq2AfAH194NtTSE/DLJJPvJR58+aRkZHhcNUiIjJYhkM4deyaU2NMHvBHYBQQBu611v7KGJMK/AUoAKqBL1hrO5yqU0RExAkNDQ288/D9BHrWEJVWjbtwLyahl6ixuSS//TvqY+ppfGs2kfWLyJp/CqeccgGxZ+k2KyIicvxybObUGJMNZFtr1xtjEoB1wHnAl4F2a+0txpgfACnW2u9/2Htp5lRERI5H1lo6dzWwu2M5+2pfIVy1g/jIDq64pZWGxib+eP0Uck/fhrd6NP3No7GuYtJL5jHjU/9GYlKi0+WLiMgQMhxmTofMsl5jzJPArw98LbLWNhwIsK9Ya8d92LkKpyIiMtT52vvZs+pV6ipX0f6PUkKV0aSdsoKob9z/f2P6IghWF/Bc+VyKy2YwY0op02bPISkpzcHKRUTkeKBwerSKMKYAeA2YDOyz1ia/77UOa+2H3hBN4VRERIaKYH+Q1tZmdlTvovbVV0iJeJGoUXVE5NZBVACA/iW3ULs9BeZvJWXRbtxjx1M05VQmTFiM2x3lcAciInI8Gg7h1PH7nBpj4oG/Addaa7uNMUd63teArwFERekvchERGVz+Vj9Vr22ldteTtMdvpDemgtiIVjLTfPz19nzuXlnJ2ZMK+faPOumry2Jg30lEeIrJGHciJ6w4izPTRzndgoiIyJDi6MypMcYNPAO8YK39xYHntqNlvSIiMgRYa+na2UjV26/Suncdft9uIuJr4ZX5eP5xLmQ1wiOXANDWZuhsTyapaTI9rjlkz1jMxIkTyc3NxeVyOdyJiIgMd5o5/QTM/inS3wOV7wbTA54CLgduOfDnkw6UJyIiI4QNWwbau9jX+hY1NW/iXb2Hlg746642anZVcefdOzG5Idy5EBmMwF+fQXPGPtrnbSJlahJ5zXdTOu90Tj55LEe6+kdEREQ+yMndek8CVgGb2X8rGYAfAmuAR4ExwD7gQmtt+4e9l2ZORUTkw9iwpW9fO9Xlb9C8ZwN9+3rpfWE67iY3qbf+J67xOw4a3/DqOH7+dw+lpaWcOw5iUnPJHDeLCSeeSlpalkNdiIiIHN5wmDkdEhsifVIKpyIiI5u1lnA4QEPDRvauWEPXvno2u5Oprq7mUylbSZ5RgUlve298eE8BtVf+N53xnaT/+/OYDDDFOYwaNYuiopPIy5uoWVARETmuKJwOEQqnIiLDW9gfpn9fB3WVm2jdW0lPaxU9L55IqC5E4hmP4zn1FWx6CxERB8b3xHHqZ/tITU3lpovHk5njJ+DPJDIun9TCKRROP4n8wkm6FlRERIaN4RBOHd+tV0RERrZQf4jO3XW0mkqa2rfQXbkHalp5rTeL6vpGTk/qpOTsNZDUDQnAZPAAvlv/TIuvl0AnxO4eQ1vbWDzxhaTHTGJUznQ6O+eTlJTkdHsiIiJyhBRORUTkqAt5Q+CCfl8/Nes207puFd7eekKhVqyrHZenE+99XyK6upCYc16Aa3/13rnx44BxsOqrObS74pgwK5/kdyYTtqm4PKOITcsnq6SMstr5pKamAVc61Xu2uscAACAASURBVKaIiIgcRQqnIiLyL7PW0vxONVtX/JGm2NfwebaQGD1ASpxl6c9yefDNbXx9/iQuvqmCd+9IHe6NJdCRQGPyLvrHeIkPR5O8+nxMXibJo4vJzJzEmDEzeGNHhq77FBERGUF0zamIiByxYL+PLc89TUPlS/S+lo3nlZkkFNXDPVcRDhpq66PwdqeR1F5IdfckXFnFZCfFkZEYIC2/mFF5E8jKysPtdjvdioiIyLCia05FRGTYstZSV1fH2jfexLX5j0SnVxFdsgeTPkDMAgjWnEPVllSiSiIoqvolM876AotPG+102SIiInKc0sypiIgQDoap3VJOZdOTNDWtIq2zlY59sXzp9nUAvPRIGqGeePrqCzBRUxhz4qeZuuAMIiP1b5wiIiJDwXCYOVU4FREZYYL9AbavXMm+8vW0PZeLa5eLUf/1c1zT39n/ehD6azLp2TmF9uxzmT17NmVlk4mNjXe4chERETkchdMhQuFUROTQvF4vFRUV7H32Udx2LdGZtbgLajAxXuiLZeCcR6nzNBB94St4xhrST5rH9BmfJzk50+nSRURE5GNQOB0iFE5FZKQL9PvZsXIlteFXae1+m+iuWlJTOrnoaz209vZz11emMvGzuxjYm4O3YzQRUSVkjptL2akXEJ+Y4HT5IiIi8gkpnA4RCqciMlIE+wPsXLWK2i2v099RSc+zs3FvG03Gp97A9Z07AQiFoL0hFnftOCq7TqF4xhzKpkyguGQCERERDncgIiIix8JwCKfayUJEZAgK+vzsemUVeztbqairY6DiHU6Y8xqRuQ2YGC/umZAEBF8dRXO8hx5fKmlvfpXUstlMPfFM0k/NAeA8Z9sQERGRIcIYsxQ4G2i21k4+8Fwq8BegAKgGvmCt7XCsRs2ciog4w1pLT3U3e16rom79DkJJjzGQsZ1Q2m7S0waIira8+usp/ORvmzlpXDHfvyoSX3c2LnchKQUzGDf/dLLHlDrdhoiIiAwBHzVzaoxZCPQCf3xfOL0VaLfW3mKM+QGQYq39/uBUfIgaFU5FRI6tcDjM3uq97HniIfq7dmAi6nCnNBGV3YR5+TS45yrwDGCfOZuBtjhqOyOx4TFkdMwitfQUJi38FBkZGU63ISIiIkPYkSzrNcYUAM+8L5xuBxZZaxuMMdnAK9bacce82MPQsl4RkU/IWstAwwB73n6Nppb1tCdvob9/F+ntXtpr4vnabzfg9XpZ8UQCCUk9hLvi8dZn0rljLAOeJKK+30revDxKptWSmpbtdDsiIiJyfIo0xpS/7/hea+29H3FOlrW2AeBAQHV0u36FUxGRI2CtZe/bG6ndtIbuxm0EAzVERDdhumNw3fYfeKwH7llCROlOMoCBAQiGM6EpmauvvprS0lKML4rCnFmMOXkyxhinWxIREZHhJWitneV0EZ+EwqmIjHg2bPE1+ajZtJ6m6nI6c3fQ07OHqIYOogbC/PCRfqqqqvjjDWNInV9JbCnYsCHUmkL/7jHsLd1JVH4U6Q0XkxKfQf6JcxgzZhputxuALzncn4iIiMhhNBljst+3rLfZyWIUTkVkWAt5QwQJ0tLawr7Vb9JbVY5/oB5czUTEtuNObsde/WvcoRhY8iv43BPEA/Hx0B/twbRkUVRYxqmnnkofUcRuv5hR46ZTNGseiYlp+7/JDY62KCIiIvKvegq4HLjlwJ9POlmMNkQSkeNWKBCgoXwtVSv66Nrpwx/eRFTRa3Tm7MF6WkmOCpGQGOCaK2LZ2tjOrRdPZ/bXNwAQ7osh0JKCryOJfX/6Iq6UZFKmdpI8zpAxeSJjimaRkTFay29FRETkuHAEu/X+GVgEpANNwI+BJ4BHgTHAPuBCa237sa/2MDUqnIrI8aK/vYPNT/+J9rpXiUjairtoNybGC9+6E7ZMIXjaP3B9+y7auwxd3ghc/enEd+RTHTiBxNwichJiSEuNIm/idEbnluByuZxuSUREROSoOJLdeoc6hVMRGZKstVRtL2f7k49T2djDUxu2kNnTzNW3V2JDLnx7cuiqziNgi0jJ/Qw5UyaSXZpNRkaGQqeIiIiMOMMhnOqaUxEZEtp2t7HpsbV0D/wef/omInN2k5oaJuZE8PyljP7+aHLmnEJn+XmUnno+ExbP1JJbERERkWFEM6ciMui6G1vY8vzfadv7OiZqB66q0cTe9y3AYp84D29PFHXeeGJjZ5IfcwbTT7+I2PhEp8sWERERGbI0cyoi8hFadldR8foKNnX0smHDBs4v2UTinHegIExCAYRaUunqjKXxjD3knZ5H2dTNZBWMcbpsERERERlkmjkVkaPChi01a2rYtupvDPSvpjXvLRITm8nICBLuTOTUz3WTlZXF/1w4mdR0D9FJZZQuPIeS6XO0PFdERETkE9LMqYiMSL1tHVQuf4HmnW8RCmwnKqUW+/3/IcaXTNTX1+D+wt/xNUXR2TmKQONU0iPmUFv7ZXJycp0uXURERESGKIVTETmsYNDP9vKV1Kx6jc09hvLtO5lGI3O+thqTGSYuE6zfja96NDUzNhOdN4b8WZcwedzPyVic73T5IiIiInIc0bJeESEUCLHvrSp2vVxF+86NxE56Am9uJYmjOoiO3j/mgR+WsKopxPmzy5g3IYA7bhyjp8xn4sIz8MQc1ytIRERERI57WtYrIseVYDDIrooK9r78V7zdO3BF1RGd1og7txFz79dwP/1ZssZkEjq/kv6WBGpqCkmKm0pOxALuePJMkjOynG5BRERERIYpzZyKDDPWWhordrJ75ys0ht6mu2sLWe1+dmyJ5ft/fptkdxSPPrv/5yXUmoKvPgtfdwaBzoVklpzGxE9PJDM/0+EuREREROTjGA4zpwqnIschay3te/ZRVb6a9n2b8fbtwb83Ft9fTyelL5nYpy6C+P0/E4EAhBpGUbdhCrs8Mxk/fjxjPZbSuYvIHFPgbCMiIiIiclQMh3CqZb0iQ1QoFKKubit7975Ox9sV9LV28VytZc+ePdx4STOeybsgC6KyIArwvTWDzsiT6J3QS9obl5BQMJoxC06iuHgBbrcHLnO6IxERERGRw9PMqYhDQv4QTZWV1FWsp6O+koGOJjqeXAhNkHnZn4g5dRUm1vve+GBzKl/5bjxFRUVcNj2JxKQoohIKSSuYQvGJC8jM0e64IiIiIiPVcJg5VTgVOQbCoTDdNQ009VfQ1FpB59Zd2LoWXmxLZe++Wj5f0EXBOW9jov3/d1LIRccZf6ErqpeYz79M9LhGvEXJpKZPYXTKbIomzCc2Psm5pkRERERkyBoO4VTLekX+BfUVu6l+eyU9LVX4B+qw4VZc0e303PNFohtGkfT5fxDx9fvfG584HhgPb16Zi01Ipzkjl8S3FmJNFtEJeaSMGU/hzLmMDpRgjAG+7FRrIiIiIiKOUDgV+QihUIh3Vj1LzUsv8GptD0++/gbnl8Zw5ve2EF0I0YD1RxJqS6E1vpmOLOjqTyXhlQuxBakk5xQzKn0yYwpnsH6XdsEVERERETkULesV+Scd9R2se2QF3V0P4x21jvicGhIT9/+cvHTndLbafE6dMZ2SjBBJo0sZPb6M0UUTiIzUv/WIiIiIiDOGw7JehVMZ0UKhEFtXvkj12ucIBzcTWjOepGcvJCK5G/72eXrr0mgOpJGUOI9x2eczce5ncLkinC5bREREROQgwyGcaqpHRpT66mo2bt3KuvJypkU9Rdz4nbiSu0mYC7Y3ls6GJGpOriH3U7lMLdxDxuICp0sWERERERkRNHMqw1bdtq1sff1J6iNXEAhUkJc4QLAplbOX7MEYw19/UkZkRByEJ5JTdgZTP/NZIqOinC5bRERERORj08ypyBDRuHsXFS89TufeCtofPImkpiQyf/Ir3PPfIB9oanLT2TAOd8d0Xn11GdOnTychIcHpskVERERE5ADNnMpxJRgMUl1dzebNm+la8wLpaW8Tk1tLRHbLe2Naz32ArqQgCZ/eS+asJCaf93nSMwucK1pERERE5BjTzKnIMdTV3MLml56iPvAaXYH1JJoWMkf18IOrE3m7ppEbzppC7hfa6N+bT2j7IhJGzWTi4vNY1DXO6dJFRERERORj0sypOC4UDLLzjdfYu/5V+tor6H5pElHrxpE1ezcRN/8IgIEB6GhMJbamjN64z1C6YBGTJk0iLu64/schEREREZGjQjOnIh9DKBRi95o32V1dxdaGZpq2bua0E1/DnVePifERPQ2igah30mhJL6A+MZWM9TdQOP80ShaerFu4iIiIiIgMYwqnctSFgiF2v7Wb3St24A39CV/iNnzpO8jI6CM2Fqpfm8r192xibG4Oi8qS6FszH1dEEan5M5lw8mdIfyLf6RZERERERGSQaVmv/Mu6urrY+sJTtFetI+CtItLTQFR6E67t44n83xsAC0+cRyAcpq7LTSiUR1rbTFJyFzL5jHNIS0tzugURERERkWFBy3pl2Gtvbmbn2tXU+d6ms/Md4po6CHW6+PbSHbS2tvL8fbnEnViLDbkINaXja8xkwJ9M+NJmRs8ZTcmEjWSVFjrdhoiIiIiIDHEKp0Lb3r3sensVrdXv4O+twvq76PjtRST0JJDx0zsw898kNQ5SU8Gf4cG/vYTzzjuPkpISAj4X6d2FlMxfRKJmQkVERERE5F+kZb0jQGdTI/saymlo2kjPrl1ENLfy2LY4qvbt48rZAcaev+6g8eH2ZOq+8guCaZBw6lbiiwNkLJzG2HGLSErKxxjjUCciIiIiInIoWtYrjhvo72fvOxto3r6ZnqbdBAZqMaaFzkfOInJvJmlnrsRzze8BiI6G6Elgx7tofWoycWkZdPoy6Vg5luiEQtILyyg5cSEpublwvsONiYiIiIjIiKJwOkQFfAGatjfRuHUHHS2r6YrdQ2/EXkxfO2kD8PjziTy9aRuXlGVy/o1bIR/iDmxya/ti8D16Mt2xCTT3ZpGw8gLM2FGkFU4gJ2sGeWOm8eIGj7MNioiIiIiIvI+W9Q6SgYFeWlp20tKwk84N++iwHuoDYQbqaxgXU44ruhd3bC8R8X1EJvXAb67BtfI0mPIO3Pnt996npysST9toVr08lebE0UxMS6Yotg1PUj7JuaXkls0kq7BIS29FREREREaQI1nWa4ypBnqAEBC01s4ajNqO1JANp8aYTwO/AiKA+621txxu7NEOp9ZafD4fA50D9Hf009dZjS/YRTC+F6+3i/7NHfSFommNTqC3o4Ocrjcx9OGK7MflHiAieoCBVbPxP3canoQBUv74LUzswEHf4617pnLDI5uYmp3JL3/XT6grgVBvHMG+eEK+BPoqF2CDk4gviiBlYjejJk8kb/xUPJ74o9aniIiIiIgMDx8jnM6y1rYOTlUfz5Bc1muMiQB+A5wO1AJrjTFPWWu3Hmp8VqLlxfsKwRosBsIG/+4COu65DAyk/cfdhDOaaYtpJSIiTJo/hY7tufz8+T68Xi93/kcAd2o3JiIMESFMVABeW4C55Yf7v8HzZ0C0H7r2H0aUQvtTU/jKLzcT6TK8tNxiA5HY3jjC/TGE+2IYiAkwkDHAQKIf19qT8MdFEc5NIC4uh4TmXM68aipX3jWFlJQUIiIiBuNjFRERERERGbKGZDgFTgB2WWv3ABhjHgHOBQ4ZTsNhCPQkAJb9q1ktoUAkgcgAWAiHXGBdWOsmEDD4exIIBGIZO3YUHo+Hvrom3K0BsJFABITdBHqL8J5ZR0RsBLFrroTkSCjwEBUVT0xzCpNPz6dqyRSSkpKIdhk8CYm4XK7/K+pr76/wG8fkQxIRERERETkg0hhT/r7je6219/7TGAu8aIyxwD2HeN1RQ3JZrzHmAuDT1torDxx/CTjRWvvNQ40/Hq45leHj6ofXMb84nUtPzHe6lBHvpme2EhFhuOEzE5wuRYAlf97AlJwkvrqwyOlSBKjvHOD8u9/gsavmkpca63Q5csDXHyxnTlEa/z6/0OlS5H2+99dNFKTHcfWiYqdLkffxBUOcc9dqfnzOJOYXpztdzpB3hMt6R1tr640xmcBLwLesta8NToUfzfXRQxxxqN18DkrRxpivGWPKjTHlwWBwkMoSgec2N/Kff9/idBkC3L+6inte3eN0GXLAU5vqufm5SqfLkAP+vqGOxm4vf357n9OlyPu8UNHEfz99yIVg4qBHy2u59fntTpch/6SmfYAdTb3c+KR+7zparLX1B/5sBv7O/hWrQ8ZQDae1QN77jnOB+vcPsNbea62dZa2dFRk5VFcni4iIiIiIOM8YE2eMSXj3MfApYEgl/6Ga6tYCJcaYQqAOuBj4N2dLEhEREREROW5lAX8/cMvJSOBP1trnnS3pYEMynFprg8aYbwIvsP9WMkuttRUOlyUiIiIiInJcOrDZ7FSn6/gwQzKcAlhrnwOec7oOEREREREROfaG6jWnIiIiIiIiMoIonIqIiIiIiIjjFE5FRERERETEcQqnIiIiIiIi4jiFUxERkWHIWut0CSIiR0Wc7QP9P21EUDgVEREZxvbfzk5E5Pg0mlae7v03ePM3Tpcig0DhVEREREREhqQ807L/wXbdYXIkUDgVERERERERxymcioiIiIjIkGSMrjUdSRRORURERERkSArZA3ElKt7ZQmRQRDpdwLESCASora3F6/U6XYqjPB4Pubm5uN1up0sREREREflYam0GjSaTUdP+zelSZBAM23BaW1tLQkICBQUFmBG6VaG1lra2NmprayksLHS6HBERERGRj6WBNP4t/j5WTFrkdCkyCIbtsl6v10taWtqIDaYAxhjS0tJG/OyxiIiIiByf0uji1v4fw86XnS5FBsGwDafAiA6m79JnICIiMrTkvntrDBH5SFmmg1mhjbBL4XQkGNbh1EmLFi3ihRdeOOi5O+64g6uvvvpffs9Vq1YxadIkpk2bxsDAwCctUURERAbZWa63WB39bf2iLXKE2mwiFa5xMHax06XIIFA4PUYuueQSHnnkkYOee+SRR7jkkksOe461lnA4fNjXH374Ya6//no2btxITEzMUatVREREBkeZa/f+B00VzhYicpxoIpVvxd0KpZ9yuhQZBAqnx8gFF1zAM888g8/nA6C6upr6+npOOumkg8ZVV1czYcIErr76ambMmEFNTQ0vvvgic+fOZcaMGVx44YX09vZy//338+ijj/LTn/6USy+91ImWREREREQGVQYd3N+3BCqfdroUGQTDdrfe9/vvpyvYWt99VN9z4uhEfnzOpMO+npaWxgknnMDzzz/PueeeyyOPPMJFF110yGtAt2/fzrJly7j77rtpbW3lpptu4uWXXyYuLo6f//zn/OIXv+BHP/oRq1ev5uyzz+aCCy44qr2IiIjI4FgTnsDXeRZyZjpdishxId80URTeC5segQnnOF2OHGNHFE6NMZnAfGA0MABsAcqttYdfgyrvLe19N5wuXbr0kOPy8/OZM2cOAG+99RZbt25l/vz5APj9fubOnTtoNYuIiMixEyRi/wOX7j8uciTcJrT/gbfL2UJkUHxoODXGnAL8AEgFNgDNgAc4DxhrjPkrcLu19uhOSx5lHzbDeSydd955XHfddaxfv56BgQFmzJhxyHFxcXHvPbbWcvrpp/PnP/95sMoUERGRQVJgGvc/6KoBTnS0FhGRo80Y4wKm8n+TmhXW2qYjPf+jZk7PBL5qrd13iG8cCZwNnA787YgrHkHi4+NZtGgRV1xxxYduhPR+c+bM4ZprrmHXrl0UFxfT399PbW0tpaWlx7haEREROdZyTOv+Bz0NzhYiInIUGWPGAt8HTgN2Ai3sn9QsNcb0A/cAf/iolbcftSHSbYcKpgDW2qC19glrrYLph7jkkkvYtGkTF1988RGNz8jI4IEHHuCSSy6hrKyMOXPmsG3btkOOnTZt2tEsVURERI6xR0KL+U3wszDxPKdLETkuGKzTJciRuQl4CBhrrT3DWvtFa+0F1toy4FwgCfjSR73JR82cbjLGbAb+DPzNWqvF3h/T5z73Oaw9/A9VQUEBW7ZsOei5xYsXs3bt2g+MfeCBBw463rhx41GpUURERAZHlc3mf4MXc01yntOliBxfDrGpqAwd1toPWybabq2940je56NmTnOA24AFwA5jzBPGmIuMMbrJpoiIiMjHNNFU83v3/0LzoVdFiYgMB2a/xcaY+4HaIz3vQ8OptTZkrX3BWvvvQB6wjP2bIVUZYx7+RBWLiIiIjDDnRbzOqREbYOeLTpciInLUGWNONMb8CtgLPAWsAsYf6fkfNXP6HmutH9gKVALdwMSPV6qIiIjIyLbLjt7/IHmMs4WIHCf89sBViLHpzhYiH8oYc7MxZifw/4DNwHSgxVr7B2ttx5G+z0eGU2PMGGPMd40x64FngAjgXGvt9H+xdhEREZERqc4e+AU7PsvZQkSOE3X/n737Do+qTPs4/n2mZCYVklBC70hTelNAEKXYAAUpYseGru6i67rLu659de29iw1lbVhYpEhvUkR6LwFCIIH0MpNMed4/JmCQlkAyz4S5P9eVyzNzzpz5xZDMuc/TdE02Ws6DjtebjiJO7Q4gDXgL+ExrnQHln83qdOucLiUw7vQr4A6t9aozCCqEEEIIIYAYXIENT6HZIEJUEQdI5E/R/2Fu876mo4hTSwIGAKOBl5VS84BIpZRNa+0t60lO13L6d6Cx1vpBKUyFEEIIIc5OV8vWwEb6ZrNBhKgiapLN+wX3wabvTUcRp1AyV9FPWusbgebA98AyYL9S6vOynud0EyIt0FprpVQTpdSLSqlvlVI/HPk6u2/h3Na3b19mzpx5zHMvv/wy48ePL/M5YmJiTvj8zTffzNdff31W+YQQQgghhAh1tVUmTf17YO9y01FEGWmt3Vrrr7XW1xAoVGee7jVHlHVCpO+AZOA14IVSX+IkRo8ezZQpU455bsqUKYwefaolgIQQQgghhBBHpOt4Ftp6QusrTUc5JyilBimltiqldiilHq6E8ycqpV5TSq1WSv0KPElg3qIyKWtx6tZav6q1nlfSmrpAa73gjBKHieHDhzNt2jSKiooASE5OJjU1lV69eh137Isvvki7du1o164dL798/Pq0Wmvuvfde2rRpwxVXXEF6enql5xdCCCFExVOmAwhRxaQTz6ORD0OjC01HqfKUUlbgDWAwgZVXRiulKnoFlilAOnAtMBw4BPy3rC8+5YRIpbyilPoXMAsoOvKk1np12XMaNumK0x/TciBcdN/vx3cYE5gZrCADvrzx2GNv+d8pT5WYmEi3bt2YMWMGQ4YMYcqUKYwcORKljv1Y+vXXX5k0aRLLly9Ha0337t25+OKL6djx98mQp06dytatW1m/fj1paWm0adOGW2+9tUzfthBCCCFCh/9IeaqkTBWiLGqRxdS8O2Ht89B+lOk4VV03YIfWeheAUmoKMITAcqEVJUFr/USpx08qpYaW9cVlbTk9H7gdeIbfu/Q+X+aIYap0196TdeldvHgxw4YNIzo6mpiYGK655hoWLVp0zDELFy5k9OjRWK1W6tatyyWXXBKU/EIIIYSoWEv9bQMbDXuYDSJEFdHMkko18mC9zLdSAeoB+0o9Til5riLNU0qNUkpZSr6uA07dqldKWVtOhwFNtdbFZxQxFJympfOUx0cnlv/1wNChQ5kwYQKrV6/G5XLRqVOn447RumzL//yxxVUIIYQQVY8q/7J/QoQ1C/7Ahq/qliFBZFNKlV5h5V2t9bulHp+ooKjoP0p3AhOAT0seW4ECpdQEQGut40714rK2nK4Fqp9xxDAVExND3759ufXWW086EVKfPn347rvvKCwspKCggKlTp9K7d+/jjpkyZQo+n48DBw4wb968YMQXQgghRAVrofYHNjJ2mg0ihDgXebXWXUp9vfuH/SlAg1KP6wOpFRlAax2rtbZore0lX5aS52JPV5hC2VtOawNblFIrOXbM6dVnmDtsjB49mmuuuea4mXuP6NSpEzfffDPdunUDYNy4cceMNwUYNmwYc+fO5fzzz6dly5ZcfPHFlZ5bCCGEEBWvmioIbLhzzAYRooqQvoMVaiXQQinVBNgPjALGVMSJlVKNtdbJp9ivgHpa65RTnaesxem/ypFNlDJs2LDTdt2dMGECEyZMOO75/Px8INCl9/XXX6+UfEIIIc5dNcnG6ZEiKJR87ruEgzqex9sMMR1FiKpFhridNa21Vyl1L4F1R63Ah1rrjRV0+ueUUhbge+BXArP0Ogmsc9oP6E+gpjzz4lQppXTASZeNOXJMOcMLIYQQopKtdI7H9VscXLnv9AeLoEjRtfjEN5DHY2qZjiKECENa6+nA9Eo474iSZWmuB24F6gCFwOaS93tKa+0+3XlO13I6Tyn1DfC91nrvkSeVUhFAL+AmYB7w0Zl8E0IIIYSoPI97bqBrs4YMNh1EHNVNbeb1iNcg5Vuo39l0HCFCnkwiVnVorTcBE8/mHKebEGkQ4AO+UEqlKqU2KaV2AduB0cBLWuuPziaAEEIIISrHh77BbKgl00OEkoHWVdRS2bDvF9NRhKhipFtvODhly2lJ0+ubwJtKKTtQA3BprbODEU4IIYQQZ+55+9s0Sq4PvGU6iiixzt8ksBHf2GgOIaoKt44IbFRvaDaICIqyLiWD1tqjtT4ghakQQghRNQy3LqTrgc9NxxClpBMf2HDKCn1ClEWKrslCW0/oUCGTyooQV+biVAghhBBCnJ0alMyeXJRnNogQVcQBEnk08mFo2MN0FFEGSqlPlVK3K6VancnrpTitJH379mXmzJnHPPfyyy8zfvx4Q4mEEEIIYVony/bARtZus0GEqCJqksXUvLGwRnqBVBGTCMzU+5pSaqdS6hul1P1lffEpi1Ol1OtKqQvPNmE4Gj16NFOmTDnmuSlTpjB69GhDiYQQQgghhKha6qkMqpEH6ZtNRxFloLWeCzwF/BN4H+gC3F3W15+u94/R6QAAIABJREFU5XQ78IJSKlkp9axSqsMZJw0zw4cPZ9q0aRQVFQGQnJxMamoqvXr1Oua45ORkWrduze23307btm0ZMGAALpcLgJ07dzJo0CA6d+5M79692bJlCz6fj6ZNm6K1Jjs7G4vFwsKFCwHo3bs3O3bsCO43KoQQIiTJCuRCiHPBfp3IVPsVcP5w01FEGSil5gBLgJHAVqCr1rrMXXxPN1vvK8ArSqlGwChgklLKCXwBTNFabzvj5EF2y4xbjntuYOOBjGo1CpfXxfifj+9uO6T5EIY2H0qWO4sJ8yccs2/SoEmnfL/ExES6devGjBkzGDJkCFOmTGHkyJEodfw02Nu3b+eLL77gvffe47rrruObb75h7Nix3HHHHbz99tu0aNGC5cuXM378eObOnUvLli3ZtGkTu3fvpnPnzixatIju3buTkpJC8+bNy/l/RgghhBBCiNB0iOq85biFYbXbmY4iymYd0BloB+QA2UqpZVprV1leXKYxp1rrPVrrZ7XWHYExwDBA2tZPo3TX3lN16W3SpAkdOgQapTt37kxycjL5+fksXbqUESNG0KFDB+68804OHDgABFpIFy5cyMKFC/n73//O4sWLWblyJV27dg3ONyaEEEKIM1JEybIY1gizQYSoIpLIZFb+cPj1I9NRRBlorf+ite5DoF7MIDAGtcyrvZyy5fSIkjVOBxFoPe0PLAAeK3dag07V0hlpizzl/nhn/GlbSk9k6NChTJgwgdWrV+NyuejUqdMJj3M4HEe3rVYrLpcLv99P9erVWbNmzXHH9+7dm7fffpvU1FQef/xxnnvuOebPn0+fPn3KnVEIIYQQwbPaX9LDqb7cUBaiLFpaUgIbW6ZB19vMhhGnpZS6F+hNoPV0D/AhsKisrz/dhEiXKaU+BFKAO4DpQDOt9Uit9XdnnDpMxMTE0LdvX2699dZyT4QUFxdHkyZN+OqrrwDQWrN27VoAunfvztKlS7FYLDidTjp06MA777xD7969K/x7EEKIsmql9jLUsth0DCGEEEKYEwm8CLTSWvfXWj9WMklSmZyuW+8/gGVAa631VVrryVrrgrMIG3ZGjx7N2rVrGTVqVLlfO3nyZD744APat29P27Zt+f7774FAS2uDBg3o0SOw3lPv3r3Jy8vj/PPPr9DsQghRHjMcD/NyxJumY4hSnvBcz0/NHjEdQ5TSWu0NbKRtMBtECCEqgdb6Oa31cq2190xef7oJkfqdWSxxxLBhw9CnmDKxcePGbNjw+wfUgw8+eHS7SZMmzJgx44SvW7To99bxMWPGMGbMmApIK8oi2TmGTB0D7DcdJey9bn+VK62/wJFF7YVRH3sv4yrrMhJMBxFHfeC7gshazRlsOog4yqL8gQ2/z2wQIYQIQWUacyqEOFaCyjcdQUBJYSpCxfFzkQvTnrO9TZPkesDbpqOIEpO9l7LJ34h3Wl9lOor4gyjc4PeDpUzzhYogkc+W8GLkt08p9ZxSaotSap1SaqpSqnqpfX9XSu1QSm1VSg00kU+IU9njr8W3vl6nP1CIMHOVdZncuAkxI2wL6XLgC9MxRCnpxDPT3w0iq5/+YBE0ceSzyXkrLHjGdBRxUlKmhgNTt4ZmA+201hcA24C/Ayil2hCYEbgtgdmB31RKWQ1lFOKEFBqFrG4vxB/FS2EaciYU38W3571gOoYo5RLLapKdY2DXAtNRRCmJKi+wsXGq2SBChDkjxanWelapQbK/APVLtocAU7TWRVrr3cAOoNtZvM/ZBT0HyP+DitfQcohh1iWmYwjgK28f8nSk6RiixKfeSzms40zHEKV86+/DrgSZyT2U9LasD2yky3LxoSRLxwQ2uo4zG0SIMBcKnepvBX4q2a4H7Cu1L6XkueMope5QSq1SSq3yeo+fDMrpdJKRkRHWxZnWmoyMDJxOp+koQlSKYuy4kYXsQ4X0KAg930X8k6FbHjAdQ5Sy3N86sJHQxGwQIaqIQu0IbNRqbTaICIpKmxBJKfUzkHSCXRO11t+XHDMR8AKTj7zsBMef8GpHa/0u8C5AdHT0ccfUr1+flJQUDh06dAbpzx1Op5P69euf/kAhqqA+lnXUVDJTb6gYY52LRUmBGko6WHZC1k7TMUQp2ZS00NmjzAYRx4hR7sDGznnQ/U6zYcQx9upaTLVfwbALRpqOIoKg0opTrfWlp9qvlLoJuBLor39v3kwBGpQ6rD6Qeibvb7fbadJE7koKcS6b4+9ILzbQ3HQQASCFqRBlUF+V3DR3ZZkNIo5ho6QXXv5Bs0HEcdKI5y3HLQyr3dZ0FBEEpmbrHQT8Dbhaa11YatcPwCillEMp1QRoAawwkVEIEfoe9d7MpcXPm44hSkzyDiRbR5uOIURIa6d2BzbyDpgNIo6RpWMDGxeMMhtEHKcW2czKHw6rPjQdRQSBqXVOXwccwGylFMAvWuu7tNYblVJfApsIdPe9R2stq1QLIU7oBussOlu2AVeYjiKEEEKIStBQpQU28tPNBhFBYaQ41VqftBee1vop4KkgxhGiXLJ1NAv9F3C16SCCO23TqK8Om44hStxim2k6ghAhTyYOC00xuAIbKSuBu4xmEcdK1nV4P2Is4y64znQUEQShMFuvEFVKIQ7cWmaIDQVLfW3ZrxNNxxBCiDNwojkghSlFR2Z+b9TTbBBxnEximWPvA7EnmmdVnGukOBWinOqqTIZYl5qOIZAWiFAzyTuQHC0zkApxKvmUrM3siDEbRBxDPk9CVx0y+KLgDvj1Y9NRRBBIcSrEGbDgNx1BACNsC6mnMkzHEEKIMtvgL1lJoE4Hs0HEMWJUSbfeDd+aDSKO08KyP7Cxa57ZICIoTE2IJESV1dj9OQDJZmMIEXJkzKkQpyctdKHp6E9F1p8VwihpORWi3DTIxYUQogp4oPguvm31oukYopQLLCVLyez/1WwQcYwC7QxstLrcbBAhwpy0nApRTsnO60u2cozmECLUfOHtxyXW36htOog46ht/H+rEn3SCfGGA68iEevZIs0HEMWR6qlAmDQLhRFpOhTgDBdphOoIQIUnLJV5ImRrxCMO2TDAdQ5TysW8A1xQ9CudJC10oiVWFgY3Vn5oNIk5BPl/CgbScClFOu/xJrNdNGWI6iBAhZrRNJqsINR0tOyBrh+kYopRsYlmtYyFCxjaGEsuR1jlPodkgQoQ5aTkVopxqqhziKDAdQwghTuvm4r/yebv3TccQpVxtWUKycwxs/cl0FFGK/0irXIQs8RNqpL00OJRSjyql9iul1pR8GeneIcWpEOUUq1z0s641HUMAn3ov5bCOMx1DlPivty+pOsF0DFHKfH9HUmMvMB1DlNLZsi2wkb3PbBBxjEO6emCj3bVmg4iTU1KmBsFLWusOJV/TTQSQ4lQIIUSFkCUyQs86xzhuWXOd6RiilHn+joGNhKZmg4iTkL9joUVTeGQm5XqdzUYRQSHFqRCiyupvXU0NlWs6hihxnW0BdVWm6RiilDhVSKIr2XQMUUrhkQn1rHazQcQx4lVeYGP7bLNBxHF26SQ+iBgL548wHaUqsCmlVpX6uqOcr79XKbVOKfWhUiq+UhKehkyIJISosn7wXURbtZvepoMIIUQZtbDsD2wUZpgNIo5xdEIkv9dsEHGcDKoxx96H26Jrmo5SFXi11l1OtlMp9TOQdIJdE4G3gCcIdB94AngBuLUyQp6KFKdCiCrrGe9oAJLNxhAlPvAOZoR1PjIKWIiTa6X2BjakOA0ph3W1wMZ5g80GEcfQGmqTxecFf4Jfn4CL7jMdqUrTWl9aluOUUu8B0yo5zglJt14hRJV1t/UHPrc/aTqGEEKU2fbofKbGRJuOIUSVUV8dMh0hLCil6pR6OAzYYCKHFKdClNMhHcdn3v6mYwjgRtssLrRuMh1DlLjN9hNxymU6hhAhbWrdVB6pmWg6hviDhCPzFxxcbzaIOIYGdui6/Md5P7S7xnScc91/lFLrlVLrgH7AX0yEkG69QpSTTGQeOpb7W9Fe7aSJ6SACgGJtJUL5TMcQomqQZTFCildbAxuNe5kNIo6TRxT7LXXBImVLZdJa32A6A0jLqRDlVkPlMtY2x3QMgdwoCDWf+AaQpyNNxxAipDUoiKN1UTFE1TAdRZQi9wpCVx2VwSuFf4PfPjUdRQSBFKdCnIFd/hNNdCaCbYh1KU0saaZjCCFEmeUqK7kWC9RuazqKKCWakiEJv35sNog4htbQUqUEHuxbaTaMCAppHxeinBq7Pwdkhlgh/mic7SfTEYSoAhTFKvBfETq8lHTrjW9kNog4ztHfFGneDgvScipEOdUkmzgKTMcQQojTurX4QSa3+8B0DFFKDX8xCT4/7FlsOooopQh7YKPZJWaDiGNoNOrIGrRyQycsSMupEOW00jm+ZOs6ozmECDXf+HrRVW2loekg4qi5/k60iW1uOoYoZWdMPhAB0bVMRxGiapGW07AgLadCnIEDOsF0BCFCjlw2hJ51jnHcskZupIWkFpeZTiBKiT0y5nTp62aDiOP83nIqwoG0nApRTjv8ddmiG3Kl6SBChJhrrNJNMdTEqUJwJZuOIU5EWU0nECcirXMhRevSNz7lZxMOpOVUiHJqbkmlrjpsOoYQQpzWkKLH+bDDl6ZjiBPZ9J3pBKKU4iPtNVGJZoOIEyhpOZUbB2FBilMhzkAnyw7TEQTwkXcAWTrGdAxRYqrvIpL9tU3HEKVs1I3JdtQ3HUOU0qgwkvbuInBlmo4iSjl4ZLiOdLcOKce2nIpwIN16hRBCVAgZFxRaNLDDeSOelU4YLOsBh4qDVgduqxUSmpqOIkSVUIAzsNG0r8kYIkik5VQIUWVdbl1BvMo3HUOUGGpdSmOLFEGhQpfcK7D73WaDiGNYPVHYNEh7UGipqzICG1tnmA0ijrPF35AXIu+H1leZjiKCQFpOhRBV1mRvf+qrQ4wwHUQA4NUWbMpvOoYooaUlOyTF6yKitB8KM0xHEaV4KZmgyhlnNog4hkaTRQwp1nqmo4ggkZZTIUSV9YrvWv7qvct0DFHiQ99gCrTDdAxRwi+1aUjaH5vB9ogIKJZeH6EkXVcPbDS60GwQcZy6KoOX8h+C3z41HUUEgRSnQogq6wHbl8yJeMB0DCFCk5bqNLRJt14hTkdraKwOBh5Ua2A2jAgKKU6FKKdcHcmH3kGmYwhgtHUuzSwHTMcQJe6w/Y9oVWQ6highLachTsklWCg5Oub08DazQcRx1vqbMTHmcWgxwHQUEQTyl1GIM6DljndIWOFvxVa/LJMRKjJlWZ+QImNOQ5ys2RhSjo45bdzHbBBxHBcOorQLXFmmo4ggkOJUiHKKUy5us/1kOoYALGhZviSEfO27WMachhC/X/NxXCw5FimCQkndwmi6uNxQTW6shRL5LAldjVQaEwv+Deu+NB1FBIEUp0KcgYW+801HEMAg60paWvabjiFK2PBhx2s6hiiR6dnD84nxfB4XazqKKCXL7iXZboearUxHEaVEUjIkYemrZoOI47RWewIbGdvNBhFBIUvJCFFOjd2fA5BsNoYQIedWm6wPGEosyg5AQ4/cMAgl1d1xRDpkpt5Q40VRpMDRoLvpKKIUrUu3aksvkHAgLadClFOzqKXUtu0xHUMAWyPsbLfbTccQJe6sXZNnE6qbjiFK+HSgKF3S7D7DSURp8SofCxp2LTAdRZRyuP4MujRuCA17mI4iSvGXnnVcxmmHBWk5FaKc0hv9QJuiImC86Shhb3i9OgCsN5xDBCyNimQpkfzNdBABQL43DYD13q2Gk4jSNsW4gAhIbG46iiilOCY5sOEpNJpDHMvrlykow420nApRTnataVUorXWhoJPbTXeX23QMUSKx2EqvPJlUJFT4tB+ARhnLDCcRJ1Svk+kEopS4rDZU8/lg1STTUUQpPr+Wbr1hRopTIcrJB2RrmWBEiD8qtHmwWVymY4gSUZYaALTxGA4iTswrN9ZCydECyCKdCkPJMcWpdOsNC1KcClEOPp8Xv1Isr1ZgOooAVjudLI90mo4hSrgsFuZHR5mOIUrYiAZgT+O7DScRJ7RjjukEopSc+M3kWK0QV9d0FFGKz69ZX+c3nkuojrSchgcpToUoB09xYCxKgdVwECGEOA2XPzAjbDEyM2yo0FpT1x1Br0IX+GUW5VDiz21Lk2KPdLcOMV6/n4NxB/ikWhxYpVU7HEhxKkQ5+HyBi4kLC6XrYqhQWsY4hop6RRY658vHSqgo8GQB0HbX+4aTiCM8Ps1BO+y228Ehw0NCiw8bOrB2iQgZx8zW23qIuSAiaOQqQohy8Hn9xPj9NPXIIK5Q0NDjYVCBzKwYCrw+P1HKTXUlrXQhwx/o4nGBW35HQkWxz09UQV0cUgCFHEvcFrZHRMBemUAslHh9pX5XGl1oLogIGmkfF6IcCt355FssHLJKv95QsNdup7i4hukYAijy+tkeERG4uBMhweMLFKUemUQkZHi8fuqpDAK3N6VADRVen//3BzG1zQURx/H5S/2e5KeBI8ZcGBEU0nIqRDkcLswEYEeELCUTKg5G55iOIAgUp0BgzJYICQW+wDqnc6MiDScRRxT7/GyNzWOXfIaElCN/vwBIaGouiDiO2+v7/cGWaeaCiKCR4lSIcnCXdI8bmuM/zZGisvn9mnqFUXR0FZuOIgBXSVf3SwtkeYxQ4fcHxsY7pQtpyCj2ymdHKCr2+iGzG7E+P9KiHVoKi30kumIDk4i1utJ0HBEEUpwKUQ55hekAzNEXG04iirw+alsysSEXe6Egt+TGjcsiF3ahoronsCRGXa/MChsqiqQ4DUnFPj9NVWrgQbUGZsOIY7iKfWQl388FCS9AfGPTcUQQSHEqRDnkl3Tr3R2323ASkeMuZLXTyUpZ5zQk5BQF1v79rFqc4STiCIs78BEf5ZcbBqEi1x3o6dHRLT0MQklhsY9d8SnkWS3Q7BLTcUQpOe58fM3eIMv1PaRvMh1HBIEUp0KUQ05BBgA1VLrhJOJwQZ7pCKIUV3GgRSjOJy1DoaLAvw+QToqhJKMw8HfrkgKXjG0MITkuD5FeO8Py8mUpmRCTW1SAishiqXcpJC8xHeecppQaoZTaqJTyK6W6/GHf35VSO5RSW5VSAyszhxSnQpSDs1pvAKL9NQ0nEWmZ+wEYmF9gOIkA8BU5qFtko5O0CIWMbPtWANp55GI7VBzKzwXgV0eSFKchJLuwGI/FS6zfD6s/Mh1HlJJbFFiebI9dJhELgg3ANcDC0k8qpdoAo4C2wCDgTaVUpS1bIcWpEOXgstRD+5ykRbY3HSXspWXuBGCoFKchoTBjD7HIepqhROlCanu9OFveZjqKKGHxV+PifA/bHcXgcZmOI0ocKsjDa9F8Ui0Oml9qOo4oJd2VYTpC2NBab9Zabz3BriHAFK11kdZ6N7AD6FZZOaQ4FaIcDu+fgbK6cVjlV8e0jJy9AORY5GcRClYemsVWRwT77DIGOFSkWBykWRxsbX2j6SiiREZBMU6KidDF0kUxhBzMP/T7gzpy8zmUZBQGitMEn+80R4oSNqXUqlJfd1TAOesB+0o9Til5rlIYvapTSj2olNJKqRolj5VS6tWSPs3rlFKdTOYT4o92ZkwBoF/uGsNJRIwrMLbx3erVDCcRADmFBwFoZLvGcBJxlDMdLD7Wpc02nUSUWHNoMTNjosmw2aB2G9NxRIn0vFLrM+elmQsijpPvigCglleK0zLyaq27lPp6t/ROpdTPSqkNJ/gacopzqhM8V2njRYwVp0qpBsBlwN5STw8GWpR83QG8ZSCaECe13l6LFsXFDHJHmY4S9mpnu+jqchMvd1NDQnZRKrE+P/H23qajCCC/yIvFFph8J2n7F4bTiCP2Fm4HwGOtBXF1DacRR2TnxnBdjosYvx/WTDYdR5SSd7g23V1uWRKrgmitL9VatzvB1/eneFkKUHqNpfpAamVlNNly+hLwEMdW3kOAT3TAL0B1pVQdI+mEOIEc/2ESimVQfigoytuGT4FfSbfeUJCjD+FXcFPyWNNRBLA/y8WfUx0AZNaTdZlDRVbxAQAc2geuLMNpxBGHM9KIwHP6A0VQuYp9JHpTef9gOq+kHzYdJ5z9AIxSSjmUUk0INCKuqKw3M3JVp5S6GtivtV77h11l7tOslLrjSH9qr9xNEUGQV5CN35rO8hjFV5FyUWHai7H7WO10yjIZIcDn12RZCimwWPhbnbam4whgy8Fcniz4MwCu6i0NpxEARV4fEXob8V4/r6VugpRVpiMJQGvNVj7js2pxJMn1ZEjZdTifgsaTeaRGgukoYUEpNUwplQL0BP6nlJoJoLXeCHwJbAJmAPdorSut25qtsk6slPoZSDrBronAP4ABJ3rZCZ474bVnSR/qdwGio6Pl+lRUumXrZ6JL/oUWKFnL0aT0vDyy7Pkn/IMhgm/7wVyuzS3k/UQnhyIanP4FotLNS16GPT5wY9teKGPoQsGmA5nkReQyJtdFh6Ji03FEiT0ZhbjtB1H5LZh6aA60Mp1IHLFu/yFcjmymOmOo7/FSETP7iJPTWk8Fpp5k31PAU8HIUWktpyfr0wzsApoAa5VSyQT6La9WSiUR5D7NQpRHbPJuvt5/wHQMAczYtBil/LTPSmRctixfYtqOHVu4PzedeHc0Nn+R6TgCSE7/guiE+dyVDpfumGE6jgB+2bOXYncjpvkuZGGkzGodKpbv2Y/VkYbNdaQ9Rdo7QsW83auPNgpMT+oG548wG0gERdC79Wqt12uta2mtG2utGxMoSDtprQ8S6NN8Y8msvT2AHK21VAMiJNj3LaVacXViZP4d49Zt/hSlNe09HThgu9Z0nLC3bfNX5FoUsaqIloWrTccJe/luD4ctO+npLqJrXiQNdaV1khLlsHFnMYlZf8LiLOC5hHjTcUSJ6dsWgYJOUSv4U60apuOIElpr1hxeBVqhiuLxWqMgOtF0LBEEoTaTyHQCLas7gPeA8WbjCBGQnXeYqc5NLKtxgekoYU9rzSLPYer4qrMotgdT4nqajhTWir0+PrGu4Kb63ShSEabjCODrdb+QY/dxnqUhOxyaLOSOmmlFXh+1kj9jhu927DLxTsjw+zVrM5cSoSNIVy1YIS3aIWNbWj751jXUdpyHzxdLlPsAHFhnOpYIAuPFaUkL6uGSba21vkdr3Uxrfb7WWmYLECHhv3Ne5Ie4SApbXES3Qmjsk4twU7YczOPwgavo3fivHI74kkPWz0xHCmufr1mCz55Fh6bX0TunHjfkFpiOFPZmrXsXq9a0bDiAf9d3s8gmXa1N+2L1WqY2WsiMhHg8yIzvoWLZrgzyDndkQP1xZCppNQ0lP67dz8BsG3c6qmPBT7XCZEhebDqWCALjxakQVcG89J9I9PoZ3m88nTI70cR2kelIYevXGZ/Q11PAPT0GU9N7kKaebaYjhbX/rXkRm9/Gn7qNoJm7Ol3cMtGLSWm5bnTRJnq7vFgbDip5VsbQmfbd2jfQaC46f4zpKKKU/y7dxr/0Lzx6QWCOTvlNCQ1FXh//XbmP0crKVfZ4vL5YchP7QZdbTEcTQSDFqRCn8ePCj9jo8NLXdgGOiEhet97A4pqjTMcKS5v3b2dt/mvcXn068dER5Fqrk2aTpZBNmbdjC9ttOxlUbCUhqhoH7QVst1lNxwpr306fyeT0nfyz/rVoa6CHh1xwmzV/+272W1fSr7CYOl1lvtFQsSE1k9SMJxlgnY6jIBWtFV5lh2b9TUcLex8tX0eO4yfyh7xJYb8ncKXcxOX1JoI90nQ0EQRSnApxCl6vh4+3vEQ1n597rnoegKKkp9jknmw4WXh6efp9zI61Y+t7LwCFKpoci0wsYoLWmmcWfo1P27n9ivcBmJGQzGsJcYaTha+NqQeps+053LYYal36ICdenU0Ek9+veXHeIxRb/NzZZBhEVqd+bneeTz9sOlpY01rzfzNeY2vCPjbU7wiNe2HR1XGqRlC3g+l4YS3H5WHSby/grDmH5nU0KIWDYjpufxX2/mI6nggCKU6FOIXJy3cSlV+ba6L7UzOhHgAx6jBN82TcQ7BNnv8xy+z7uLS4Ol06XweAXXtw+F2Gk4Wn/y1cyqFtzbiz2Xs0rS8Xc6b5/JpHpo3j6QZZpPe8ByLlpk0oeH/BCg7af2NooY9W/R8BIMPXkrW1HoRabQynC18f/LKafeoburqK6D/wRVCKGFc/rvKOgjxZF9ikB77/LwWxaxmbX0jDiOoARNT6iXnZX8N+mQ0+HMj88kKcxObUbJ6dmUznRk/wl+u6HX3eg51sey2DycLPjoO7+XDH89TBz9+HfXL0+dE5EXQpXmkwWXhasWsT3iV3830M1Lvot2P2SRdSMyZM+4Btjj2MdcfQ+JKHAIi2xXLHASddqskEbiZs3J9N9XnP8F/HAWpc+ylERAOQ4UhnWmwC11WrZzhheNp8IJNP1k3AHuHjsWYjUHXbA2DFx9/33QW//RP6PGg4ZXj6ZMU61ue/RBPt4U89HgZnHBQUQ2QK65XDdDwRJNJyKsQJbN39GxN/vJj2sfN5bnh7lPq9e5wbB4ecjQymCy/5riKe/XYk2VbNgy3Gk1iz6dF9DbwxtC+SZRmCKflQOo/MuZ6XkrxYBj+Cxfr7GFPpRGrGq0tmMSfjDWrQhL8M/xwsgZ9JhNXBqtxh6Db3GE4YfpIzsnlzyt1cZ5lLrQ53Edvq8qP7dPRidhZ9Bq4sgwnD06G8IiZ8cx9Zzkz+4a9Bg0sePbov17mYgY26Q5uh5gKGsWU7M3j/1/vRVjfPxLUnsvOtpiMJQ6Q4FeIPth8+yNi5D7I3ws+NF7Yiqdqx654pNBYt6wYGg8tdxG+vjubZw9t5KO4yLrv43mP277HnsdohyzIEy96MdO6fegUH7R4eSLycep2HH7O/gCgOR0hrUDBNWTKbj7c+hIMEpgyfRERis6P7PP5iFjuj2F2jrcGE4WfX4Syu/fbnk5iAAAAgAElEQVROFtbYwC9tRhA9+Ilj9kfrQqp70mGf9PoIpvQ8N8++8yHvZczhsXwrV4/5Dqy/f354rdkctGRAjeYGU4an1Xuz+OLj13krcxPP+WrQ5pqPQR17u1N65YQP6dYrRCmrtixm3JJ/4bVk8ud2zzG466DjjhmcX0iTQlkIurLtzszgtc9H8KzrV7a1uo+R1z5x3DFzo1NZFhXDhQbyhZs1e7YzceZIUiOKecDZnauHPH/cMTp/DLFJMtYxWL5YsZftP01lZM1chg5+hdrRicfsL/DkEdXoA7bud3Fl29aGUoaX1ftSuH/6TRQ7DnFjiwfpceFNxx1ToKLw22pAvU4GEoanrWmZ3P3lY0zN+xx7tfpcM/bH48ZlK62xaD9k7IRSN3lE5fpu3Wa+mvUYn1hm4q/RibbXfw125x+Okn454USKUyFKzF0wmUd3Po1d2Xm48yuMuuDiEx53a6YFX1x0kNOFl7k71/OX+X/GH3OYC5NuY/jw4wvTI+Qjq/KtXreOH+eOJa2aj4nV+jN82KsnPK5acV0a+GRcUGUr9vq4e+qzzF3XgIub3sRbl/+ZyKSWJz2+RvKPwN+DFzBMfbxqKa+vmYDXkc/fal3N2BMUpgBebBRbnBBdI8gJw9N36zfwyLKH0HH7mFV3OCMGPg4xNY87TgE2XQwbv4U+fw1+0DDj92sen/kDM1MfxZtYTHJiT5qN+RIcMccf7IkjyeINfkhhhBSnIux5PR6WfzKRXnvfpXvNegzp9RS9TlKYisrl8/n5z9cP8VXhz/hVJBM7vcLwC/qd9HitkL4+lcjt8TL5yxcZtu0V7ld+Bnd5jG69Tr5OYx/1MZfvWwDIbJeVZX3Kbh773y1sdWbQ87z+vDf6euzWU4/QyWh4fA8QUXHcHh+vT/+VtzcsIqaunVebjKNPn/tPerwdDxF+F+QdhNikICYNL8VePw9/9zpLct/HYrfzcJf/MKLtYNOxBHAgO5+bpz5PqvqWBtrDczUupdnlL4H1xGWJSh3GU87pQU4pTJHiVIS1hat/YNKKf/HsoT1sqH4pj930HlGxp+6WeHsDH129mbwQpIzh4kCOi+u/ncghy2zaeBSPXDGJtvVamY4Vthbu3sKEuf/AqvfQJyqJejdMplvdU/88fozPZIX1Ar4LUsZw4vdrnvnxOaZlfIrbobnNV5f7Rz6BOkVhemTIVlF0/SClDD8zN61hwczHeCh7ObrNx4y7+h7iI0/Q8lNKy+yO/DtjBhxYK8VpJVmzL5u7//c0+ZE/cZ7Pz9Pt7qLlaQpTqz+BNkXFQUoYnrTWfLV8N6+uuYucyAOcF3MRH1x4F9XqyHJk4ndSnIqwlJmbwbNf3cIs6y6iIjQ/tb6Tm659+rgB+CfiV4E/sKJi5LsLWfjta3y+xcGBiDYM6liX5y4bjy0iynS0sJSWnc2/p45nHpvwW+yMbHIPzW8ei7KdfjkSl3KSba8WhJThZcOOPXw1fTzfVtvLeV4ff2vzJ7r2urvMr3fm7q7EdOEpJSubJ76bwCpWEF3Nz+0Jl/HXq7vCaQpTgAhfDA290kWxMqTlFjD5h6nU2fo1OnYYV7Sow5O97yzT50mMuxcf5L0IsvxspVi2ex8vztxDx32f8X/V15N5/iOMuahsf8d07Rk8Y43n4UrOKEKDFKcirPj9mre++ytTM38izW7hwqJqPHz5ezSpX75PIylNz57Wmg9nvsbX+96nhzuXO+J60uiW92mUWPbxvIPzGtKjSC68K4LPr3lv6W+8sfV+sGXTvTiWB4dOoVXNhmU+h017cfryKzFleNmWtp8537/IyP1TeNBSSGLsRdw9+gPssbXL9PooWyz3pkbSt2BRJScNH4XFHp6d9gLzsj4ny6bp61L8pfsjNOk4qsznyHHuYSrRDKvEnOHGVezlPzMnMf/gW/QoyuZOh4+rrn+amHpnUGnKB3yF2puVy6M/Ps2v3p/BdRUjBt/HgMQrsbS6oszn8DkOsTihG3S5pRKTilAhxakIC1pr5mxO58XZ20iwLCbaaeHR+uO4tv/JxwWd/GQVny/cfLPwY77c8iqbHMXUUX6aNhpNn6vK1nJd2h7bALC0on0l5QwHXp+fqXM+I2nFF7yRfxPxLdrzl/MHMqzjleX+eSTobBq7MiopafhIzsrg39MmstazmDrKw6C45tQa/hL3NSrf7K52SwTtCm0kxVlPf7A4pSKvjxnzFlCw8hm+q5tKC5+PR5OGcMmgJ45ZjqQsMqK28W5EnBSnFcDt8fLKz58yb+/b7HcW0lB5uah2H6LHvQLO8vXiyHPOZ0RsEl9VUtZwsy8rl6enP8cG149k23108FmZMHoEHZPaUN7maY3Cb7GBPbJywoqQIsWpOKf5/X4+WvQpP219iZwDV1MU1Y9ber3N0K5tsdtkfcxg0lrz26pl/O+Xv/FlXDbxNj9jVDvuG/U60SeYObEs1jphnarHnRWcNRx4vD7em/UmP6V8yEF7MV/qXN4dGEOPvq+hylmUioqx+1A6j859jV8LZqKsLnp6rNzaZjxNet1d7hsFAB5/Eb9Fe4hXEUhn6zNTWOzh3/O/ZsfWz5l8eBHFFgc1nFfTf8TTWKPP7O+WOHuuYh/Tlq5myZqJzIk/QJLNy59Vc24c+gL2GiefufpU/JY8dtnluuBs7css5IfZc1iQ8Tibo92c7/fwz5heXDbw36gz/Ky34CfGlQJ7lkGjnhWcWIQaKU7FOcnn9fHWok/5ePc3uK3JJFrhuvOt3D7k4tPObHk6/fMVDSx/XINLnIzf7+eDRZ9TfcWHXJu/mlh7FMT15N5hrxIfX++szp1r/RGl8oFxFRM2DBQWu3nzf08x//CP7InwkWT1cbOzK3UnvEST6ISzOvelWU240rergpKGj+TDBbyzYCeNdo1ldS1NTXtHJva8n0ubdTqjovSIQm8B79RxE+O2yTC6ckrPzeXl6U8yM385xfZMIqMT2FbrFs67ciIDZAkYYw7m5vPEvMnU3DSHf7h/5iKbhbYJPbnx6hdw1DyzolRUjCW7dvP+/Ke4du8W7mE9nSLjyE8axKXX/hsVc3a/MwqIch+E1N+kOA0DUpyKc4orP5e1P73HK5kfscEJSicwoPa9PNb3RmKcFdMdpHpOX+Lr1qmQc53L8goLeHneu0xNm4nHup/+UX7OS7qD84b8lX/GVUyLQ01fOg59qELOda7LyMlj9fT3se/6kI/rQwPl566ILoy79gUcZ3nhcESSJ5rzZKKXMtFa8+2K6Xyz7lVWZXWE3Iv5d6NreKtxIr0u/pPpeGFrR3o+Ly2awcKc58BaSH2cDD7v/7i76zXYy9l9V1ScFXuS+XD+UyzxbgBbPufXaE5W3FjqXvYXbk9oYjpe2PL6/Hy2+hc+X/s2h62r8VgVV8a5yWv7ED173QXRiRXyPp7iJDyNWkHP8RVyPhHapDgV54TVG2cwddnLPJiyhh64WFGtERcmXsK4q/5NpKNixyhMtg6mf3wS11boWc8dabluHpn7ARsz3iXH5semk7iq7p+Z2Gc00Y6KnYE305oInH4W2XA2b+cmXlr+MfEZC/g4YzMp9sY8FT+MKwY9hLWCZ0ROduSw0hZBjwo967kl11XIO7NeZenBb9nhdBFl89O/QVseu7IftWIrZw1GGSZ/al6fn8+WfMfhNT/Q8VAys7mHBi3b8ufGPbiy+1iUzBxuhMfnZ8b6A7y46nUyrD+hLT6aW5IY0+VJhre5pMKHH2gUPmWDtjIa+HTSc91Mm7+Ij1JfICtyP1jtXO6J4eY2o2h9/d1gc1To+xUdHMaAbm0r9JwidElxKqosT1EBX855mmn7p7MhwovdpmlfrTOte97Hn7pdhrKcXffdkymu8wSb3B2BNyrl/FWR1poflnxM/KrZPJh+FTmJ22gYX4d7EnsycvBELCdZWPtsuVUkfiWX3n/k9hTz9vz3Wbp7EpsdbrS20LJaG/b1eJgGXYZQv5LGlC6ulkKKL1aK0xPYl3qADTPe4wfXVyyOgVo2HzfqZtwy4Elq1KucKb0UMnb4VPZmpPHu7KdZmbeQ1Agv3SPcjEpsxLLre5NYc0SlvW/D7N686Jtbaeev6ralH+D9n5/n4u2byPREU5DUitZ1+vGP+u1o3+XGck9AVVZWf22qWdpBjeaVcv6qTmvNt+tX8Nnaxazf3JpJ1qfomZSNqjeOv150M4mRp14j/mw4KOaiDf+EmjdBi0sr7X2qspSsQr5cuc90jAohxamoclzFPv47/ysm7XuCTJuF2srP5Z7WjOn7CO2bX1Dp719d59Es/9dKf5+q4HB2Kh/MfJSFub+wN0Lzn6Is7m/Tjx4Dn6BZzbhKf3+ndoGWpUuOSDuQwuxVm3k5eS5FcdOobfUzMKIXdw/4F80S65qOF3ZcRW4+mvsq81K+5ZmDuxnsc2OJaU6/+v0Ydtk/sEed3RhfUX5aa9Zv2sCnSyYy176LYouipfZxl6Ut1181ker1OlR6hlTdlB/q/4fb6nWu9PeqKnw+P58t+5pZW95js/UAHotiQGQefVuN5IYRT2CxVP6Nlih3D4bZYuDwDilQS9mfncXbc19h1eHppDhc4Ldxfc93aNryNZ6tkwRxlf/ZYk/6jk+KF/P4oe5SnJZS5PHx8co5zN70Dat2XgXnyA1JKU5FleDXfn5c8Aq/7Unmm92XU+h20KdhHNfEDeSGwX8lIabsa2OeLRcODjkaBO39QtGWDQt49ZdHWWk9hNuiaK7hRms3Ot32KLVrBO//zY05cfRy/RK09wtFbk8Rn8x+gbkp33FzVgqN8xvTrNG/6NG8B+O7DMBRwd3aT0efG5+NZ2XFno28tPILNubOQVvzqW3xsbxWL+L6PcTAlt2DliPKFsODKZH0iq/YLnZV0a7MNF5Z8C7XbJpD7+I1XBQThY6tz1UtR3Nxn3vAFrzhATmRO5nl9HKbTKzE/sw85s76gEn5H3HI7iPW4mdAURRDWo6i55jxQV06xIKf8QcmwsZCuPihoL1vKPL5Nb9s2sX8Jc8yNWIZRRZoqjzc5m3AqAHPktSgfMtanbWITPZUUg+squiX5D28vuK/rM2ZDREHcVg1t190LTf16k39Z0ynO3vykxYhLS1rH8+v/JY5+7/HYzlE4yLo1/JGxvZsQtfGQ40seeFWDrIjwm9CpIzCXGbPfJEOm2bS0rOJg3Xr0NVXg4EtbuKqi2/DcpazIJ+JBJ+Txh5f0N83FKzZ9SufLXyaFb6tZNkUta0+tid059ph/+S/LYN84VAinOvSYq+fOZvTSJn3PG/GzcSDlXhLe65P6srNvcbijK68Lm8nY7PY+SZ/LB36h+dcvV6fj8+WfMbUHd+z07ILpXx0dtqo2egOBlx2F0NrNzWSSzlXs79oJ+TdALFJRjKYVFBcxNvLf2LLpp95InUaY1UWa2rWoZWzE9cN+DvV6pxvJFdu5Fx6Jl7Aso43GHn/ULA+dR8fLniBRvs2cFfBGs6z+ciu0ZDBDa+kX78HUNLbw5icQg8/rdrMhtWvMa36L/gUxEY0Y1jS9dxRvw3VWvcHy7mxprUUpyL0aM2BjYuYvPhJvnCkUmxR2LzNuLLWEO7rdT11Es3ebbbix+53G80QTHPXzeLVTTPY6VpIlC7mc6+HX5pN4J2B46hZ6+yWgjlbWyOycGgnlTONTOjxeLysXfITnpXv81T1reyz2+jktXFxwkBGDZyIM6ryu1KfSq6KIT0ieL0YQsHSrcuYsvQ/rHBZObj3Fq6Orcfdzub0HPAk5zduZzSbx1/EprhsdkQlUDmjWkPTgaw8Plu1k0/3/hltyyAWTUvn5dzdeQyXtaj8brunE4WLSG8WpK6B8waZjhM0i3ZsZMqSZ1jm3Y7HVkCENYGChNZkXDiOFzpdXWljSctKKxeFKg/iwuvmc0FRMW8un873O78lX63GpxQjIl0cTBpB3X6381ywW0nFUT6/5pt1q/hh9Rs0ydjJ/+VvZqjFS4yjMYO7/ZX2na83HbFSSHEqQkZuXjqTZvyL7juX08O9k66OWHYltKB/+wcY1u2KoIw5KYuROYXUs20zHaNSuT0+3l4+mx+3/pt0Wyb4rdS29uSWVlfT+MYBNLOFxt255ZFp/BYZfc4Xp6tSdvLS8k9JzpzFnNRNeHQkY6tdTJsut3FBu8tMxzvKknsrtetWNx2j0uW4Cvhg1gssSfuRbQ43NqVpFlGXJ27swCWtLsdqmWA6IgBun4vIul+xe58bLji3LzDdHg+T5n9AyrYf+Ev6eqYWPUliy/ZcXqshd3YZSlzNZqYjHpVPNMX2GtDoQtNRKl1+kZcZqzbz+sZvORzxDRb8tPHH0rPlo9zZ5Sqc9lCabV2jtD9w06Cu+ZsYlUlrzYb9uayc9x3f5L/D3qg8FNFcSlNuaNSPjhfdFdQu1eJYW9IO8fbCd9mUNY0DjnysFk0rZxH5ja4nsdctPFyn/VmtgR3qpDgVxq3YMJ0py19iqSWVAouFIgcU1n+YdoNu580aoTcmZ0iuFUvMuflHe/G6WWQs+5KfDzZjOnFUq29hJO0Yc9ljNK0vC5wHk8tTzFtLv2Hl1pfZEFGIRpFga8PyjkO5aMB4RjljTEc8Tm2PnVZFOaZjVJrtu5LZNec9tudOZVINK3UtPkZ6m3DdhQ/QsvUlpuOdVML+c3dm2BU7NzB58TOs8a4j06ZJcno5WKMzXw/uRN3mN5mOd0J+ZcWn7OA029OhsmitmbZuKT+seonLD+6ie1EubyY+Qo+kUTzYujetml0ElTSb/tmy4IdtM8/Z4jQtN5+3573D9PRVpO26jvG25dxV/RB7z3+Ecd1H4gipmwWluJNobVtvOkWlKizyMmPjQb5ctQ+f5z62xLhpqjzcWVSTazrdSt32o8HuNB0zKKQ4FUb4/Jr5Ww4yafGVrHUUY7dqOrrj6N/0BkaMuQO7PXT/aeZaNBHKbzpGhckrzOWjGU+z8PBMtji8jCjKZ1B8NNcNGseFze7GamAsaXmcawvJ7EtJYeniOfxnn4fiWq9Q3aoYTCtGD/gPHeuG9mLzbWxf0CltCTDKdJQKk1mYz3uznueX9GmMzj3Idfl5JEW2pXbCJQy77G/YnLGmI57WoSbn1rqNbo+PpUvmsnjdi3wdF1g6obMXbovtxYgB/0dk9fqGE55ahC4mwlcAWckQ39h0nAqzLyuL9+a8zOrMn9jjcGGzarrHKFTHO5lz2XWoMLmwDjV+v+bL1Qv5ae2rbFXbKLBCjDWKPw2szrhOz1At+lUI9cmG0gfwsPNL0ykqnNaaudu38enyt9nlXsT+PX+mXlw97qjdg78k2OnZ+y+o6uE3AWeI/2sU55pNu5bzzeJ3mJE6lv3ZLi6pk8AQe3VGX/xP2jat/GVgKsLf6nrp4M2mqneSS0neyhtzHmKR2kGO1UIdi5/hujVjrv4/mjeuGneNz5VOLYVFRXzy86ss2P81rdyHeDAjn/mNv6Ldec9wW6dLcUZUjdlWZ1crYLWtI31NB6kAs9cv4PUNP7LLtRCsLupbfGQldCdnxL9o3+iCKjWG0+M8NyYxmbdzE2+s/IyhybMZ695GQ5sTHdmGEZ3vpk3HEVWmm1uLrJ68fWgapG+u8sWpz69ZtmE7KQs/4l3nDxyyKxopL7f4GjGy55+p12pglfm52H116F1QaDpGhUnJLGDBgp/J3/Ihr9fdhd2q6eWGQUmXMOiSv2MJs7G1oeRAbj5vLPiU2Qd/psC+HaU0nX3F/HVwBFf07IvF0s90RKOkOBWVzufzMGn1TD7b/CWZ/t8ATc/43ky8YhCXtp5JhC20W+bOJS5PEZ/9/Dqd1s6kg2sFMYnVaemoyaVJw7jusgew2atGEXSuWL1zHZMXPsWv/o1k2BQ1rD7aRLWi8PLHeat5F9Pxyq2ICApsUaZjnLEcVxHT16exZfFUtkS/yS6Hk9r2btzScjCjOgzA6gi9rtRlEZ25yXSEM5ZZWMg7P7/OkoM/sseRjdYW1sU3Yne962ja7zb+FV31Cm+rthOjq3afjy3pabywdAqbDixgzsGF9FIePAktqNPicvr3nYCKrHpjzyOLuvBcXobpGGfF7fHy0dJpLNj6LvXc+3g+cy/FKgKHrxuXX3gvtc4bVGVuFhyjznc8YK/JC6rqXi96fX5mb9zNrqX/IyntW6Y1OkyU1UmvGiO5v+twWlerc8529S8vKU5FpcnLSmf29Gd42zWLA3YFvhjaRV3OhPMH07VtX9PxzkpVu6xYv+tXnl/9Hb/lzkVbc3lDF7C64c3cftnd1Gp4nul4Z2xIXlP6Fm41HaNcijweVi75Ge+KD1ng/JVZ1aLpWGzlloTLGDnw/3BGVb2LuiMcFBPtLTYdo1y01sxaN5+pq15kFQc5vPNvdKzRknERF9Lukvtp1LBq9CI4kShbDP/YG81F+atNRykXrTXrd+3jy9VpfJf1T5RjP3UsPvrEXcv9ve+kZY3Q7rZ7OpmR23jfEsc400HKye3x8sHKeSza8AJb7AfwWfxERjZgfasb6ND7Zm6oX5X6E5xKVfuEhxV79/LKL1NYlzMLItKIsvtp6Ysgq98zxHcbzc1V8GZBaT57IRsTO0HP8aajlNuG1DTeWfQ2W3KmU9eXy8dpqeTbEqgbO/D/27vv8KjK7IHj3zMlFQiEhB56qNJBekeKIGDFAiIoFtRF0WV1bYiCZe0NRUWxoYiiCEjvIFV67x0SSEL6ZMr7+yPDLr/dqEDKnSTn8zw8zL1z7zuH5PLeOfdtXN3pEezR9awO8d9E5GZgLFAfuNoYs8G/vzqwC7jwhWuNMeb+/IpDk1OV5xau/YbTG6ZyU9xv9LJ5+KF8dXqV7ceIPk9RKqTwTyRUWJ45+nyGmTt28t6GscTLLnwIpWyNuKXmDbQe1IfgkMK/5MfvwX056WzJE1YHcgl2njnOq6u+YkviLD6N20s9lyAR3bmh+R00atTX6vDyRGmTTCVXvNVhXJL41GQ+mfcqa8/N5UCwC4fd0MxdhtvuuooesXURKfxzQNvFQZUsO6UpHK0NcckpfLzwTXbE/cqHpw7gNcNpVv8GrqldnjsadsReRNZYTA49wvdBJQpNcrrv9HlWLp3H28dO4i33KcFOobu7BP2ueZeuNVpYHV6eSQmdT6cylVludSCXKCnDxawtp9i7+hey7B+xtbRQKrg2t0R3ZniDayhZrY3VIeapwvTIIM3lYfKahSzd8wGHnYfIskFtcdPWWQH3za9Sol5v2lq8dNIf2A7cAHyUw3sHjDEF8rRWk1OVJ1LTE/n81+dZfG4J+4J9XOXIomZkHyK7jOTrJm2tDq9Y2XdiN2sXTSTjWBbjU3tRqmYi1zhiGdz6bzRrULTGMewOime3zR2wyanX5+WzjQtZsvlltjvP4hMoaa/Hwcb9adLtPjqHRlgdYrFijOH33bs5tXQKpc/N4JuYIGJsXgb7Yrm98xPE1CxadZXb52JZRBbhNlvAjpE3xjBz8wpmbXyDHbYDpNihssPLpqo9eLrn7YTHFI65CIqa1Ew3nyz/ltWHPqdt2gkeTT7FkWofE1Lz7zzY4jpKhpWxOsQ8Z8RNcoDOInyBMYa5O3fy49o32eDbSfLJQVwTVpqR9jLc0uqfNG9Q+B+q5cRmfJRKPwr7FkBs4CyfdjFjDEv3H2L25gR+3XaW3hETOB55jl6ZQv+qvWnd4VEkwtq14f+KMWYXgFjc9VuTU5UrZ5Iz+einB5nvWcN5u40qNsPNtuYMGziOmPLVrQ4vXww4b6O8I7BagH1eL9OXf8rcfVPYFHSeSh4PL0k53h30ND0bziPYGRjrkuY1l30RPkkAAmNdyQvOJZxl26JvGXe4DmcinyPU7qKnO5rrr3mPdtUbWB1evrn2XCyDPLutDuN/JKSn8cH8t1gfN4Pa7kRejz/LofAmvFW+N127PYItqPCOk/0zLq+L76IzqeiyB1xyej4ti2WLZ3Fm58e8U+E4DoehbaaDPlWupW+Pf2AL0Qc3VlhzaD9fLn+VXe51xDu9lHT68IWVIbnT84xtOgAcRXtegkBtnTubmsF7iz5l06lpHA5JwGcX6pkS3Hx9M26+qiMigblsUl5yelLh/HGrw/gfCWmZvLFyFisOf8P54H2UievJtY3uZFD1ZxlX2kd4rR4FvXSSQ0Q2XLQ9yRgzKQ/KrSEim4Bk4GljzIo8KDNHmpyqy+b1uvlu4ZusPV2fWXvstCzpoVZkOD0q3sxt14zG4SiaidAFiWn9ia5S3uowAEhJTeXLWc8zK2Uex4IMJR0+urkrcEOzh2jc8nqKeptDpPcsds5YHca/zV4/gxmb3+EMp/n5xEk6lJ5A+XovM7jF1USEFM0E6GKlvMFU8HqtDuPf1u7fzBsbvmFn+jKwp1PZ5qVS+FWkDRxPjcpXEdgL8+ShAJp8Z/H+nby97nOqnVnNO+e3kSahZPpacWOH0VSKLVo9OwoLl9vLko3bOL/yYxaFLea3cAdNvV6GlWjOTd2eIrRcfatDLJaMMaw7eJJtS3+i1pFvWVrtHDYnDHKXZlCT4dRqfic4AnRd0jzmzqhOSEwzaDnM6lCA7N/NxiNneXfZs2x1b8LjTMMRFM5NmU5u7tOOuo0sHX/tMcb84YyKIrIQqJDDW08ZY37+g9NOAVWNMedEpAXwk4g0NMYk50G8/0OTU3XJzqSeZ8LyKaw6NR2XI5GW52ozvP14Brf5gGplC//4xUs1x9mI1JKVGWxhDGv3rCN+yRTanvqFuuFZzCsTxd1B7RjaZxxlSudU5xRN8fby+MTam3NKRjofz53A8rNzOBDkJszho11WWXZf+yrjWvUrnDMjXqE9oWeZ5w2ll4UxeLw+luw5w4xVO6iRdh+7SocR7WzFsKtu4fYGHQrtjLuFWUaWmw+XfcHKQ5PZG5yMMTbCyzTgZOM7qNRhCA/r78QSe+PjeWXF16w/N+v767kAACAASURBVJupp3fT25tMpZBWjKp7Cw1bDYPAHBOXrww2aG5tK2SqK4uJS6ey+vBnpNrjmXv8OGnBUbweOYAmnR/GEVlsHqv9W9bZnnRu19DqMEh1ZfHlbyvwrFtM19SZZFTJoqGUoFvjFxnS+FqcheD/jDGmxxWc4wJc/tcbReQAUAfY8KcnXiFNTtVfOnZwF28sHsUK+xlcNh/B1GRoyU6MuOFxIkoW7hngroQn+m0OZNQD2hfo53o9Xiavn80Xe6aTxGbuzTxPjZINqNZ+JD+17ocE+FiZ/OCWIDxiTTezIydPs3vuhySe/Y7PyjuoIl4G05A7e42jYqXi2dKwucRp4k1JS5LTE4lxfDR3HEvT1nHi9C1E2ZrSr/KNTGvZnXoNrUyXi69TiSn8uHonHx/6Em/JZUTZvfQMas/Ins9Tq2wlq8OzTLWEHnzmmW/JZ/t8hu+3rmfGhn+xz76HLJshPKgG+1uOon6r6+kYVcuSuAKB0xtDOVsHsGj9z03HjvPa6q/YmjIPnGeJdHq5xlOKpAEfUbbxjbQoBIlPfgkmi2s23gcR90PD6wv88zceO86Hy95hb8YiMhwuFmUcxx0Ry8cNHyCi5RAILlngMRUkEYkGEowxXhGpCcQCB/Pr8zQ5VTnyeb0sWfUNZdZOo0nqClzlo2jiKE+ftq9y41XtLB8sbaXSJFMtfVuBfV5KppuxSz5jx/EPOBHkBV84TSJuoHvnfjSoUfjWwsxL4b5UfJIvvUpy5PP5+HrzCj7Z+iU9EtbyTPJR9oXU59nIntzQ+0nszsAai1wcLNi6jOnrXmWT/QgZNqGez8dNnWJ5oH03nPbLfkCscskYw/R1c5i19R3uiTtATGZt6te6j1axnXiwUVeCS0ZbHaLljkgM79T+nEerFdwDzvPpbhYsW8qnO5I4FjUeu91wjctG306v07VB9wKLI5CFZDXlrtQkOLkJKjUrkM90e338uv0EC1ZtpF3y02ytKEQE1eG2GoO5J7Y1wRWuKpA4Ap2j8neMdxzg/aRjBfaZLo+XqevWMHP7KxxyHsJjgya+LPraYgkaOpGS1ToUuZ5RInI98C4QDcwWkc3GmF5AJ2CciHgAL3C/MSYhv+LQ5FT9PxmZaUye/SwLEhZwyOljmiuJ9ZWH8GyfUVSIqW11eAEhlTBOh+R/t5q9R3dxeMFUHj/alqyoxVQKDWdESGOGDXyDksGaBAEMTypLz/RV+f45qa5M3p33GivP/MjRIDeYEOLLt+dcv0nE1mlLbL5HoC6W5fGxauVifGve57Wo3cQ77LR3hTAwdjDdOz8Edr21AYQ5wnn+cEnalM3/n0diejrvz3uT3+JncDTYRajDx76I8lzX6z76tyz4lo5Alhq2hWW2VB4Nyf+fy4r9e/lqxXjc6VuYHH+IlBL3ElfjWe5q0ZHy4VFF7st1bt0R9wbsCcr35PRIQhLvLnyH1UmLOJvSiApZA3g0vCpT6t9M86sDY1xlIBFbBucLqHfY3rgEvl63h1mbUmnp+5ETVQ/QL0O4qdZAmnR4FMLLFkgcVjDGzABm5LD/B+CHgopD7+AKgJPxR5j0699Z6t7BOYeNKmK43dmG6IfGU7d0YEz+EyhcBJPiyL/Kad76n/h+0xtsciYw/fQphlarQ/uub9C6esVi3WKdk1DjoLQv/yZ7iUs8z/dr9jPp4Af4SqyjGj5uKHMLo3qMJjKsaHfjCUSnkpJ4f85Ydqcs5ZtTh/AQwgN0pXnHUVStVbSWgckLNrHzRuYI3m7fmPzqRHvsbAqrZn/BZ1kfcTLIEGPzcLepw5Duz1K2atFZAzMvOYJ3cjZrDySOgDLV87x8j9fHlN/mM3/Hm+wNPoFXoI3dcLTVGIZ1ub9If7nOjZTQ2TQuW4OtbR/Ml/KNMSzeu48vVk5gr/xOqt1QzebjulatGdOhB3ZbYC6REijyc1o3Ywy/7NjFB+snk2jmE5lWjhbVXmZIyyd4Q64jvG7vgp5xt1jT5LSYO3I2mS/WHGfR78s5X3Un9TzBDC1/I4N7j8HpKL7jG/6MEw+h3pQ8LdPr8fLFoneZd/grdoS4CHX66OIpR9r17/JYEVubNC9tDY4nwxbG7Xlc7qpda/lq5TjuPb2DMNfVNIgdRJf6A7mnWQ/tuvsnkiQCCcr7pH3T8aO8uPIT9qXPxdgzqCte1jcaSds+YxhYBNdbzCtun4u4yJ3sJpa8TBONMczZvY2pqyfy4tGF3CpxZJSuRER0Lwb2GosttPjNRXA5Qo0LpzcFzuzM0+Q0OdPNnKWr2bXjFX6MOkZokI++rnAGN7ufei2Hgq1oz6SfewaDD0JK5WmpWR4f8zYd4PjSyWwPncnvJW20z/ByU6UedO/2DFJCu7r/tfx5MJ+R5WXiynnM3vcxZ4IPImJo4wlhSO0WdOpzYdhUtXz5bPXHNDktphbu38o3Sx4lzZ3IhuMv0q9xa25u2IgOjQp2kp/CaERiOlFBR/OkrExXFut+nULQ9o94v3IGJRxwk6nLPb0nULlivTz5jKJse8g5toWE50lyaoxh+qrvmLnjPbYGJ2FzQpPIGAa0H8GwpvpE+1I4zj9AzZi8SRaNMaw/nMjaOc/zafhiPAjlg5rzWPWO9GkzBCkmSyjkhtuXRXC5uZw+4oJmHXJfnsfLp8um8u2hHzjrOIDYbRwvU4GI9hMY1vx67U59iZKlBA5HNNTOm7Geu8/E8+LyKZQ7+BuvpS8i2eYgKrIlg7s+TZnquf+9Fy8GDq2AGh1zXdLZ1AzeXPAxv8dNZUL8Ma7zpLDFWZ9H6t5JbMt7is0yMIHoaGIyM5dvwbFpChlllpNe0knHMtcxpvNIapSuanV4xZ7eSYqZn5dP4vWDy0mULdgdNrpKNEtHtyUmSlsfLlWnNDuOXM4QezI5keeWfIL7xFQ+jzvAKVtFnijRn2v7/IOwEtrl6vLkrrOPx+tj1ZJfeP/AOHaFZFHC6aOvpwLDOz1D7Tpd8ibEYqKaN5lmqcfAXPlEER6vj48XfcT0g+c4cLgZD4QaBtlL07vvBzSLaZTHERcPpc6szdX5KZluPlq1ni8PjcPnPEFJm9Cu7C080+keYiKKz9JVecUgGLGBI3f3kXk7tjD1txfYaDsE9izqlWvI2ciHKdd1JA9bNONs4eavsw7nLjndcuIUE1ZMYU/qL3idyVSyezhVqSlNuj9Nk6qtdZzvFTDpNWjv/D3X5Sw/cIiPlr/OId9KXoyPoxtpHA3ryCPtRxJep4/+bgKEJqfFgPF52bVsOis2v8Z7kZk4fU6alR7E811GUCNSx5NerhNOQ5jNQ90rOHf/if1MnP8k881hsGdSKbgimzo+RNMud3KTtjpcttykpWlZLibNnUjXzdPo7NvBxjLRtAptzvDrXqJsdPFdTiE3KgT/QFTSWmDkZZ+bnpXFu3P+xbL46RwL8lDKUYLnB9zOLc17ERqs/zdy43TsbVd03tGERGbM/YS6excxKfMeytQpyS2R1/NA2yGERek0YFcqxHgJ9aZD3G4od3k9ZHw+w8JdZ5iw+m3OOWfjcPhoYaowrPN4OlfXMb5W2nA4geW/fsXUoClkOrKIDK7HqFLNGdBpNPYyxW9t0rxkznVgZMjkKzrX5zN8v3kTUze8wlHnTtw2aOvKIrxWb+j6T6pG6WSfgUbv+EWYx53Fp7OeJWr/bG5MO0qQRHE2qj339X+VqDL6tPtKvVzOTQNvCpfTWepkUgbjF81mZfJ4fDYPtbzVGX71U/Sv3ybf4lQ5S0xLZtyiSSyK/wXjSKBFUCa76j7FI9c+iC043OrwCrXl4W62BDVj4GWck5KRxWez/sXM899xxmmoKl4edDTnrutfI6SU1lO5k90K4LNfXgvd9hPH+WD+U2wyv1PCeLjD7uKX22Ko2+T7/Aiy2IlNbM8X8TMg4cAlJ6cut5cPl00nfP1cItPjyCjbnRY1+jO2QVeq1+6mLT55IMhTnQHnL28+CZ/PMHXjWj7e/AuHD7TlnZCFPFrGTfWBn9Oumj4ssJLL4+XnTSeZvHwXrojHOB9k6J3uZUjszdTvMBp0bHzA0uS0CMp0ZfLxL/9kbuJ8jgYJbcINlWpPoPm1d/NUcIjV4RUrG/b8xtbF75B5Moj55nrq1O/EUw27065pf6tDK3bOpCTz1MIP2Z3wJecdEGqrwdB6o2l/Rx/sOvYnT3jEicvmuKQvykfPxbNi7uc02/c1vZzHWR5djrvCu3Br3wk49EtDnioVv/GSjlu5fyefLX2GrfY9ZNqENhmG22rcStTQJ4jKZRdUdWXOZ7h4a/4k1pz+kuMhGYwOTqJNZGtWDXsQR5D+TvJSsLshTyYnXtKxLo+Xict+YfG+dzgcEgdOB4/07kuPZpMJKxEBdp1QMi9JlakMCYrhy+C/nnAvKT2LVxd/y7qj37H/6L00qBjJI8HNaRXbmkot7851d3qV/zQ5LUI8Xh+Tfn6emQk/cMIpVEW4v0Qf7rl1HMGalBaoFVsX8sWaF1gfdI5qDg9PlWvF0iG9qFz6ctqU1F+5+Xxd+qZv/9Nj4hLOsX725/zjQG2I+YHqphyPl+/OgF5P6tI8eSzUZBDhyQJj/jBB3XXmFO/M/SebvevplJFOD2coWa1f4PvOwxCn1lN5KcQexksHS9E6eu+fHrd+1yEOzHuf0MwZbKwQSpdMB0OuGkGLdvfrDK/54Gz4dibYy/DPPzsmJZOX57zMpuSfiQvyUMnu4SGpxaDbvyGsgo69zg8GLy6BIGP+cG7YlEw3ny1ewJxjL3AiJJVSQV4GZ0VwV4+XKVezXYHGW5z4xHC6VF1o+cdrwB5LTGHs4q9Ye+5HJPg05YI9vDnAxsA2HRDJ/QRXquBocloEuFxpzN56jPeWnaac5wDOssKo0v0Z1m8sdn16V6CWbVnIlLVj2RCURJDT0N1dnns6v0D9OjoLcn5YHDaAzaGdeCmH93afPMDEuX/nhHsX006dZE+Vt2nT/TvaVa9e0GEWG6VIITorLsfkdPuJwzy7bCJ7XQsRWxZt3XZ61R9J+S6PagKUT2xio6TPRkgOX7WNMUzbup53NkykQ8oWXkk6wNHSrZje9H5qN7lRu4nmo/Sg0ywKCc0xOT2ZlM6cuXOotet9UiocI8LhZERwc24a8DKO0jEFHmtxkhY6j5Zlq7I1h/fOpmby+cJfqbT5W+5iEasrRTLQV40h3cYSXl3v71Y6fDaNTxfMZnHaSyQ7PZQIqcKw2qMYXrkhzmq6/nVhpMlpIeb2unl18UcsPTKRCkk1CHKMYWivl+nZoLwmpQVs//7dnJz5ImmexWyLLkMfTxXuv+ZValRrYnVoRdqhoF0csKX/v317Tx3mvV8fY43sIdMGHQjnQP+vGd28nzVBFnPHEtL5dMEmOH03+yKcxAS34+n2D9G+6lWaAOUzt8/FL5EZOOxBXPj6bIxh2obFTP99PLuD48EWjLdyJzIHfkTV6q0sjbc4O3wuiX8u/IRtyT/z06l9VHA4qREzjGrdHkHCIq0Or9g6k5LOS7++x5bz3xEk6fzMGdLq3sy3PcdAWZ04r6DY8BGRfgS2/whX3QDAjlPxTJo/jbb7F/C0bTkSXZq25a+jd7+3tFdUIafJaSHk9br5YOGbTD4xD489jkqmBF3qdWLYtR2x2fQ/ZH4bnOggMigMgJWH9zB+2asMSFjI3edT2FZxAN/3eITqMZqUFgSfrMZLHPAccYlJ/PLjc0yyLSLDBu1dwQxr/hhXt8qLVVDVpRh4tgF3uncAsP3YIf61+AV+O9oMXLV5q3JH+jfoTPOrB1scZfHh8XmYF+miTqaNdsawfN9Znlv6PueCfyA8yEfv4FY83v91yofr8lVWOXA2kX/9+gKbs5aQ5vAQGVqPs73upVbTgYRfwvg6lT9Onk/lmQVfsjZxGhJ0llq4GRzeGOeoOZTVmXctIcYHXjebjp/i1YX/4qB3EWLz8LwzDm+jOxnXdTToGqVFgianhYjx+di1bBqf7hzP/BIQ5CvHrTWeY0zH63E6tFtcQdmUeTtVw85zx+SBbLEdAmNjX2Q70m99keYV9UlqQSrjSyDJnsA7U8Yw6OA0hkoi+8rX4frmf6N16yFWh1fsOI2dTBEe/+wW1tt24xJoUyuaV/uOoEJEH6vDK7b2+NL55PWhBCelk1m6P+3r3coLza4junJjq0Mr1ib/to83vBMQZzItPB5ubfEivZveaHVYxd66XftZuq4/6yrGUyq4Gg82vJfbanfEFlHF6tCKrazU+ngi6zNo4woOMZ4Mu6Gt28Wwcp0ofeMLoOv6FimanBYGxvD9wreouuEbWrv20ju4EjHRfXjg9pcJduosowVtVbiNpSV+xmkMDYO7Mq7HP6gbrTctK5xwRJNiT+ALz0J6hsdgen7My02vsTqsYmt9yWO8FVEFMbvplOlkePNRNG81VLvvWmx+mFDSu4K7Ylpz6/DbCXLqrd9KNhNEGa+P2CM/0KjhAO5q1oZe1VuCv0eOsobxr5w98kRPZpWcQNNy19Gz93jtIhoA3IntCc5cyI7qy+ic7mJY5WtoceNYKBFtdWgqH+gdKsDNXP4x3+z+gB3BHm4Nc+Op+SwdBzzINSE6q6VVGlRLx5XVlXEtB1E/VidCsFLHyteyOT6KMe1HUK9Wc02CLBZRrhGdkxMY3vhemre+S38fFmtcqRwN3dVpZMvgges+IbJaa6tDUsCAWo/Rc/czVOxzE1PbDrU6HOV3TY2ObExIZ+Lo/lSMvIWKOlFbQIgIdTKwaSXqRA7nRUpQu8OjoOOwizQxxlgdQ66Fh4ebtLQ0q8PIU2u2/sqHvz3HxpAMynh99HS24OGBbxNRsozVoSmllFJKKaUCjIikG2PCrY4jN7TlNMAkpWfx9qJ97Dsyln3haQzw1WXU9R8QXaaC1aEppZRSSimlVL6xrOVURB4GHgI8wGxjzBj//ieBuwEv8DdjzLy/KqsotJyeTznLGzPuZ+OxFuxMbcwdTdwMaVuTOtV0wgqllFJKKaXUn9OW0yskIl2BAUBjY4xLRMr59zcAbgUaApWAhSJSxxjjtSLOguDxenhp5Vf8cOBjvPZkuka6ee3uB6lXoZTVoSmllFJKKaVUgbGqW+8DwMvGGBeAMSbOv38A8K1//yER2Q9cDfxmTZj566fFb/Lhwa844czC6avOqDqjuav9DToznFJKKaWUUqrYsSo5rQN0FJHxQCbwuDFmPVAZWHPRccf9+/6HiNwL3AsQFFS4llOJP7KbM9Mf44hjG97wUtwSdR9P9Bqpa5UqpZRSSimliq18S05FZCGQ0yw+T/k/twzQBmgFTBORmkBOTYY5Doo1xkwCJkH2mNO8iDm/xSee5LUZI+gTt4mWGV7qVR3KHTc9QVSETomtlFJKKaWUKt7yLTk1xvT4o/dE5AHgR5M9G9M6EfEBUWS3lMZcdGgV4GR+xVhQPB437/34OD+lLOScw4Ytog6xt0+mV9WaVoemlFJKKaWUUgHBqm69PwHdgKUiUgcIAs4CM4FvROQNsidEigXWWRRjnpi7+ksmbX+NfcE+Yr12RtceRf/Od1sdllJKKaWUUkoFFKuS08nAZBHZDmQBQ/2tqDtEZBqwk+wlZh4srDP1pmS6eX3+Xvbums25KA/3hHXjocFvYLc7rQ5NKaWUUkoppQKOZeuc5qVAWufU63Xz7g9/Y8vxNJbGD2Jwq0qM7BhNxegqVoemlFJKKaWUKqJ0nVP1/yw5tJknl40lTQ7QJCyEGSPb0zSmtNVhKaWUUkoppVTA0+Q0DyQknWTCj8OZZzuJ8YXRr9y9vNDrAZxO/fEqpZRSSiml1KXQ7Ck3jGHP4i85vGEc88uH0NRTi2cHTiI2qrzVkSmllFJKKaVUoaLJ6RXasX81K+eM4b6EbdhsNXil+hj6dLnd6rCUUkoppZRSqlDS5PQyuT1uXvtuBDOy1uMoATERD9Pt1meIDQ62OjSllFJKKaWUKrQ0Ob0MyzbO5J2Nz7A32EejrGBGd3iblg07Wh2WUkoppZRSShV6NqsDKAw8Xh/vzV3G37c+yWmHhxFh3fnqnvWamCqllFJKKaUKPRH5l4jsFpGtIjJDREpf9N6TIrJfRPaISK98jUPXOf1za7Yt4qXlIWw5lsSgWvO4r/d91IxpmC+fpZRSSimllFJXIjfrnIpIT2CxMcYjIq8AGGP+ISINgKnA1UAlYCFQxxjjzau4L6bdev9AujuTv08fyUrXOhqk9uC928fQr3Ffq8NSSimllFJKqTxljJl/0eYa4Cb/6wHAt8YYF3BIRPaTnaj+lh9xaHKagwV7VvHE6ufJsp2iVVZlnr1zFNUrVrI6LKWUUkoppZTKb8OB7/yvK5OdrF5w3L8vXxSJ5DQ9Pd2ISEZ+lL2d7Xx2X838KFoVHw7AY3UQSuVAr00VqPTaVIFMr08VqMJEZMNF25OMMZMubIjIQqBCDuc9ZYz52X/MU2Rf319fOC2H4/NtXGiRSE6B340xLa0OQqmciMgGvT5VINJrUwUqvTZVINPrUwWqv7o2jTE9/uL8oUA/oLv5z8REx4GYiw6rApzMbax/RGfrVUoppZRSSqliTER6A/8A+htj0i96ayZwq4gEi0gNIBZYl19xFJWWU6WUUkoppZRSV+Y9IBhYICIAa4wx9xtjdojINGAn2d19H8yvmXqh6CSnk/76EKUso9enClR6bapApdemCmR6fapAdcXXpjGm9p+8Nx4Yf6VlX44isc6pUkoppZRSSqnCTcecKqWUUkoppZSyXKFPTkWkt4jsEZH9IvKE1fGo4ktEYkRkiYjsEpEdIjLKvz9SRBaIyD7/32WsjlUVTyJiF5FNIjLLv11DRNb6r83vRCTI6hhV8SQipUVkuojs9tehbbXuVIFARB7139O3i8hUEQnRulNZRUQmi0iciGy/aF+OdaVke8efI20VkebWRX7pCnVyKiJ24H2gD9AAuE1EGlgblSrGPMBjxpj6QBvgQf/1+ASwyBgTCyzybytlhVHArou2XwHe9F+bicDdlkSlFLwNzDXG1AOakH2dat2pLCUilYG/AS2NMVcBduBWtO5U1vkc6P1f+/6oruxD9sy6scC9wMQCijFXCnVyClwN7DfGHDTGZAHfAgMsjkkVU8aYU8aY3/2vU8j+clWZ7Gtyiv+wKcBAayJUxZmIVAH6Ap/4twXoBkz3H6LXprKEiJQCOgGfAhhjsowxSWjdqQKDAwgVEQcQBpxC605lEWPMciDhv3b/UV05APjCZFsDlBaRigUT6ZUr7MlpZeDYRdvH/fuUspSIVAeaAWuB8saYU5CdwALlrItMFWNvAWMAn3+7LJBkjPH4t7X+VFapCcQDn/m7nX8iIuFo3aksZow5AbwGHCU7KT0PbETrThVY/qiuLJR5UmFPTiWHfTr9sLKUiJQAfgAeMcYkWx2PUiLSD4gzxmy8eHcOh2r9qazgAJoDE40xzYA0tAuvCgD+sXsDgBpAJSCc7K6S/03rThWICuV9vrAnp8eBmIu2qwAnLYpFKUTESXZi+rUx5kf/7jMXulH4/46zKj5VbLUH+ovIYbKHP3QjuyW1tL+rGmj9qaxzHDhujFnr355OdrKqdaeyWg/gkDEm3hjjBn4E2qF1pwosf1RXFso8qbAnp+uBWP+saUFkD1KfaXFMqpjyj+H7FNhljHnjordmAkP9r4cCPxd0bKp4M8Y8aYypYoypTnY9udgYcwewBLjJf5hem8oSxpjTwDERqevf1R3YidadynpHgTYiEua/x1+4NrXuVIHkj+rKmcCd/ll72wDnL3T/DWRiTMC37v4pEbmW7BYAOzDZGDPe4pBUMSUiHYAVwDb+M67vn2SPO50GVCX7RnezMea/B7MrVSBEpAvwuDGmn4jUJLslNRLYBAw2xrisjE8VTyLSlOzJuoKAg8Awsh+ga92pLCUizwODyJ6RfxNwD9nj9rTuVAVORKYCXYAo4AzwHPATOdSV/gcq75E9u286MMwYs8GKuC9HoU9OlVJKKaWUUkoVfoW9W69SSimllFJKqSJAk1OllFJKKaWUUpbT5FQppZRSSimllOU0OVVKKaWUUkopZTlNTpVSSimllFJKWU6TU6WUUkoppZRSlnNYHYBSSimVn0SkLLDIv1kB8ALx/u10Y0y7fPjMZsCDxph7clnOQ0CaMeazvIlMKaWUCly6zqlSSqliQ0TGAqnGmNfy+XO+B140xmzJZTlhwCpjTLO8iUwppZQKXNqtVymlVLElIqn+v7uIyDIRmSYie0XkZRG5Q0TWicg2EanlPy5aRH4QkfX+P+1zKLMk0PhCYioiY0VkiojMF5HDInKDiLzqL3euiDj9x70sIjtFZKuIvAZgjEkHDovI1QX1M1FKKaWsosmpUkopla0JMApoBAwB6hhjrgY+AR72H/M28KYxphVwo/+9/9YS2P5f+2oBfYEBwFfAEmNMIyAD6CsikcD1QENjTGPgxYvO3QB0zP0/TymllApsOuZUKaWUyrbeGHMKQEQOAPP9+7cBXf2vewANROTCOaVEpKQxJuWicirynzGtF/xqjHGLyDbADsy9qOzqwCwgE/hERGb7ty+IA+rl8t+mlFJKBTxNTpVSSqlsrote+y7a9vGf+6UNaGuMyfiTcjKAkJzKNsb4RMRt/jPhgw9wGGM8/q673YFbgYeAbv5jQvxlKqWUUkWadutVSimlLt18shNHAESkaQ7H7AJqX06hIlICiDDGzAEeAS4utw7/201YKaWUKnI0OVVKKaUu3d+Alv5Ji3YC9//3AcaY3UCEf2KkS1USmCUiW4FlwKMXvdceWJiLmJVSSqlCQZeSUUoppfKYiDwKpBhjcpow6XLKaQaMNsYMyZvIlFJKqcClLadKKaVU3pvI/x/DeqWigGfyoByllFIq4GnLqVJKKaWUUkopy2nLqVJKKaWUUkopy2lyqpRSSimlnAQy+gAAAC1JREFUlFLKcpqcKqWUUkoppZSynCanSimllFJKKaUsp8mpUkoppZRSSinL/R/Dme7kpE7KiwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -616,7 +615,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -678,8 +677,8 @@ "---------------\n", "ref [0.006 0.03 0.025 0.036 0.033 0.031 0.041]\n", "old [ 6.128 5.615 6.107 10.186 17.895 4.997 20.766]\n", - "new [32413643.009 32591616.327 35974587.741 51016349.639 77907589.627\n", - " 37451353.637 11279320.151]\n", + "new [32413643.009 32591616.326 35974587.74 51016349.64 77907589.627\n", + " 37451353.635 11279320.152]\n", "\n", "w at spike time:\n", "---------------\n", @@ -720,7 +719,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -753,9 +752,31 @@ "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -798,7 +819,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -824,7 +845,7 @@ "plt.show();" ] }, - { + { "cell_type": "markdown", "metadata": {}, "source": [ @@ -836,12 +857,12 @@ "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.\n", "\n", "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." - ] + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -855,9 +876,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.9.13" } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/environment.yml b/environment.yml index 7253af4d15..88aae833e9 100644 --- a/environment.yml +++ b/environment.yml @@ -64,6 +64,7 @@ dependencies: # Building NEST documentation - PyYAML>=4.2b1 + - assimulo - breathe - csvkit - docutils From 4321e6f88353c1848a416109668a7fe687e74989 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Tue, 20 Sep 2022 14:04:30 +0200 Subject: [PATCH 028/150] Refactored any_true() function to use MPI_Allreduce --- nestkernel/mpi_manager.cpp | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index d9e9528ef3..693b4243f3 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -799,21 +799,10 @@ nest::MPIManager::any_true( const bool my_bool ) return my_bool; } - // since there is no MPI_BOOL we first convert to int - int my_int = my_bool; - - std::vector< int > all_int( get_num_processes() ); - MPI_Allgather( &my_int, 1, MPI_INT, &all_int[ 0 ], 1, MPI_INT, comm ); - // check if any MPI process sent a "true" - for ( unsigned int i = 0; i < all_int.size(); ++i ) - { - if ( all_int[ i ] != 0 ) - { - return true; - } - } - - return false; + const int my_int = my_bool; + int global_int; + MPI_Allreduce( &my_int, &global_int, 1, MPI_INT, MPI_LOR, comm ); + return global_int == 1; } // average communication time for a packet size of num_bytes using Allgather From b0bb0e43eb044a3e17a3e3028113d284c5d762c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Tue, 20 Sep 2022 14:08:38 +0200 Subject: [PATCH 029/150] Refactored check_rng_synchrony() to replace min/max checks --- nestkernel/mpi_manager.cpp | 19 ++++++++----------- nestkernel/mpi_manager.h | 15 +++------------ nestkernel/random_manager.cpp | 16 ++++++++-------- 3 files changed, 19 insertions(+), 31 deletions(-) diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index 693b4243f3..9f51ddc455 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -719,18 +719,15 @@ nest::MPIManager::communicate_Allreduce_sum( std::vector< double >& send_buffer, MPI_Allreduce( &send_buffer[ 0 ], &recv_buffer[ 0 ], send_buffer.size(), MPI_Type< double >::type, MPI_SUM, comm ); } -double -nest::MPIManager::min_cross_ranks( double value ) -{ - MPI_Allreduce( MPI_IN_PLACE, &value, 1, MPI_DOUBLE, MPI_MIN, comm ); - return value; -} - -double -nest::MPIManager::max_cross_ranks( double value ) +bool +nest::MPIManager::equal_cross_ranks( const double value ) { - MPI_Allreduce( MPI_IN_PLACE, &value, 1, MPI_DOUBLE, MPI_MAX, comm ); - return value; + // Flipping the sign of one argument to check both min and max values. + double values[ 2 ]; + values[ 0 ] = -value; + values[ 1 ] = value; + MPI_Allreduce( MPI_IN_PLACE, &values, 2, MPI_DOUBLE, MPI_MIN, comm ); + return values[ 0 ] == -values[ 1 ]; } void diff --git a/nestkernel/mpi_manager.h b/nestkernel/mpi_manager.h index 70723c4e67..6395ac1038 100644 --- a/nestkernel/mpi_manager.h +++ b/nestkernel/mpi_manager.h @@ -161,21 +161,12 @@ class MPIManager : public ManagerInterface void communicate_Allreduce_sum( std::vector< double >& send_buffer, std::vector< double >& recv_buffer ); /** - * Minimum across all ranks. + * Equal across all ranks. * * @param value value on calling rank - * @return minimum value across all ranks + * @return true if values across all ranks are equal, false otherwise */ - double min_cross_ranks( double value ); - - /** - * Maximum across all ranks. - * - * @param value value on calling rank - * @return maximum value across all ranks - */ - double max_cross_ranks( double value ); - + bool equal_cross_ranks( const double value ); std::string get_processor_name(); diff --git a/nestkernel/random_manager.cpp b/nestkernel/random_manager.cpp index 558d520142..f23d8b100b 100644 --- a/nestkernel/random_manager.cpp +++ b/nestkernel/random_manager.cpp @@ -196,9 +196,7 @@ nest::RandomManager::check_rng_synchrony() const for ( auto n = 0; n < NUM_ROUNDS; ++n ) { const auto r = rank_synced_rng_->drand(); - const auto min = kernel().mpi_manager.min_cross_ranks( r ); - const auto max = kernel().mpi_manager.max_cross_ranks( r ); - if ( min != max ) + if ( not kernel().mpi_manager.equal_cross_ranks( r ) ) { throw KernelException( "Rank-synchronized random number generators are out of sync." ); } @@ -217,11 +215,13 @@ nest::RandomManager::check_rng_synchrony() const local_max = std::max( r, local_max ); } - // Finding the local min and max on each thread and then determining the - // global min/max, ensures that all ranks will learn about sync errors. - const long min = kernel().mpi_manager.min_cross_ranks( local_min ); - const long max = kernel().mpi_manager.max_cross_ranks( local_max ); - if ( min != max ) + // If local values are not equal, flag this in local_min. + if ( local_min != local_max ) + { + local_min = -1; + } + + if ( not kernel().mpi_manager.equal_cross_ranks( local_min ) ) { throw KernelException( "Thread-synchronized random number generators are out of sync." ); } From 71d241623a28c88d8100b7039f6171e8b3fc3dff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Tue, 20 Sep 2022 14:43:24 +0200 Subject: [PATCH 030/150] Replaced functions in the no-MPI case --- nestkernel/mpi_manager.cpp | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index 9f51ddc455..39298ff808 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -1073,16 +1073,10 @@ nest::MPIManager::communicate_Allreduce_sum( std::vector< double >& send_buffer, recv_buffer.swap( send_buffer ); } -double -nest::MPIManager::min_cross_ranks( double value ) -{ - return value; -} - -double -nest::MPIManager::max_cross_ranks( double value ) +bool +nest::MPIManager::equal_cross_ranks( const double ) { - return value; + return true; } void From b27039143ac4e89e0581aba011be1b4276d56167 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Wed, 21 Sep 2022 12:01:45 +0200 Subject: [PATCH 031/150] Switch from -1 to -inf to flag if local values are not equal --- nestkernel/mpi_manager.cpp | 2 +- nestkernel/mpi_manager.h | 3 ++- nestkernel/random_manager.cpp | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index 39298ff808..e650553717 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -727,7 +727,7 @@ nest::MPIManager::equal_cross_ranks( const double value ) values[ 0 ] = -value; values[ 1 ] = value; MPI_Allreduce( MPI_IN_PLACE, &values, 2, MPI_DOUBLE, MPI_MIN, comm ); - return values[ 0 ] == -values[ 1 ]; + return values[ 0 ] == -values[ 1 ] and values[ 1 ] != -std::numeric_limits< double >::infinity(); } void diff --git a/nestkernel/mpi_manager.h b/nestkernel/mpi_manager.h index 6395ac1038..c5c72d2fe1 100644 --- a/nestkernel/mpi_manager.h +++ b/nestkernel/mpi_manager.h @@ -164,7 +164,8 @@ class MPIManager : public ManagerInterface * Equal across all ranks. * * @param value value on calling rank - * @return true if values across all ranks are equal, false otherwise + * @return true if values across all ranks are equal, false otherwise or if + * any rank passes -inf as value */ bool equal_cross_ranks( const double value ); diff --git a/nestkernel/random_manager.cpp b/nestkernel/random_manager.cpp index f23d8b100b..cd5a2219f1 100644 --- a/nestkernel/random_manager.cpp +++ b/nestkernel/random_manager.cpp @@ -218,7 +218,7 @@ nest::RandomManager::check_rng_synchrony() const // If local values are not equal, flag this in local_min. if ( local_min != local_max ) { - local_min = -1; + local_min = -std::numeric_limits< double >::infinity(); } if ( not kernel().mpi_manager.equal_cross_ranks( local_min ) ) From d38c74c272b832ad2711c7ac8dc94d289f99e940 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Wed, 21 Sep 2022 14:30:15 +0200 Subject: [PATCH 032/150] Updated documentation for Parameter creation --- pynest/nest/lib/hl_api_types.py | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/pynest/nest/lib/hl_api_types.py b/pynest/nest/lib/hl_api_types.py index 9821e851c3..1f848e9c4f 100644 --- a/pynest/nest/lib/hl_api_types.py +++ b/pynest/nest/lib/hl_api_types.py @@ -85,7 +85,7 @@ def CreateParameter(parametertype, specs): **Parameter types** Some available parameter types (`parametertype` parameter), their function and - acceptable keys for their corresponding specification dictionaries + acceptable keys for their corresponding specification dictionaries: * Constant :: @@ -100,21 +100,15 @@ def CreateParameter(parametertype, specs): {'min' : float, # minimum value, default: 0.0 'max' : float} # maximum value, default: 1.0 - # random parameter with normal distribution, optionally truncated - # to [min,max) + # random parameter with normal distribution 'normal': {'mean' : float, # mean value, default: 0.0 - 'sigma': float, # standard deviation, default: 1.0 - 'min' : float, # minimum value, default: -inf - 'max' : float} # maximum value, default: +inf + 'std' : float} # standard deviation, default: 1.0 - # random parameter with lognormal distribution, - # optionally truncated to [min,max) + # random parameter with lognormal distribution 'lognormal' : - {'mu' : float, # mean value of logarithm, default: 0.0 - 'sigma': float, # standard deviation of log, default: 1.0 - 'min' : float, # minimum value, default: -inf - 'max' : float} # maximum value, default: +inf + {'mean' : float, # mean value of logarithm, default: 0.0 + 'std' : float} # standard deviation of log, default: 1.0 """ return sli_func('CreateParameter', {parametertype: specs}) @@ -1080,7 +1074,7 @@ def GetValue(self): import nest # normal distribution parameter - P = nest.CreateParameter('normal', {'mean': 0.0, 'sigma': 1.0}) + P = nest.CreateParameter('normal', {'mean': 0.0, 'std': 1.0}) # get out value P.GetValue() From a1f783385e519dfe239322e82e82a282cc1c86eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20Bakke=20M=C3=B8rk?= Date: Thu, 22 Sep 2022 09:19:36 +0200 Subject: [PATCH 033/150] Updated documentation text Co-authored-by: jessica-mitchell --- pynest/nest/lib/hl_api_types.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/lib/hl_api_types.py b/pynest/nest/lib/hl_api_types.py index 1f848e9c4f..317fce7f34 100644 --- a/pynest/nest/lib/hl_api_types.py +++ b/pynest/nest/lib/hl_api_types.py @@ -84,7 +84,7 @@ def CreateParameter(parametertype, specs): **Parameter types** - Some available parameter types (`parametertype` parameter), their function and + Examples of available parameter types (`parametertype` parameter), with their function and acceptable keys for their corresponding specification dictionaries: * Constant From 3d4aeaa965ac501ced14313101e9ea5d7d22703d Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 22 Sep 2022 14:21:34 +0200 Subject: [PATCH 034/150] Refactoring all C/C++ files to make them more compliant to the C++ standard --- .gitignore | 4 - doc/slidoc/index.html | 1 - libnestutil/beta_normalization_factor.h | 2 +- libnestutil/lockptr.h | 28 ++-- libnestutil/stopwatch.h | 2 +- models/aeif_cond_alpha.cpp | 20 +-- models/aeif_cond_alpha.h | 26 +-- models/aeif_cond_alpha_multisynapse.cpp | 20 +-- models/aeif_cond_alpha_multisynapse.h | 24 +-- models/aeif_cond_beta_multisynapse.cpp | 20 +-- models/aeif_cond_beta_multisynapse.h | 24 +-- models/aeif_cond_exp.cpp | 20 +-- models/aeif_cond_exp.h | 26 +-- models/aeif_psc_alpha.cpp | 20 +-- models/aeif_psc_delta.h | 26 +-- models/aeif_psc_delta_clopath.cpp | 20 +-- models/aeif_psc_delta_clopath.h | 26 +-- models/aeif_psc_exp.h | 26 +-- models/amat2_psc_exp.h | 24 +-- models/binary_neuron.h | 30 ++-- models/clopath_synapse.h | 2 +- models/cm_default.h | 22 +-- models/cont_delay_synapse.h | 16 +- models/correlation_detector.h | 22 +-- models/correlomatrix_detector.h | 24 +-- models/correlospinmatrix_detector.h | 26 +-- models/gif_cond_exp.cpp | 20 +-- models/gif_cond_exp_multisynapse.h | 26 +-- models/gif_pop_psc_exp.h | 24 +-- models/gif_psc_exp_multisynapse.h | 24 +-- models/ginzburg_neuron.h | 4 +- models/glif_cond.cpp | 22 +-- models/glif_cond.h | 26 +-- models/glif_psc.cpp | 2 +- models/glif_psc.h | 24 +-- models/hh_cond_beta_gap_traub.cpp | 20 +-- models/hh_cond_beta_gap_traub.h | 30 ++-- models/hh_cond_exp_traub.h | 26 +-- models/hh_psc_alpha.cpp | 20 +-- models/hh_psc_alpha.h | 26 +-- models/hh_psc_alpha_clopath.cpp | 20 +-- models/hh_psc_alpha_clopath.h | 26 +-- models/hh_psc_alpha_gap.cpp | 20 +-- models/hh_psc_alpha_gap.h | 32 ++-- models/ht_neuron.cpp | 20 +-- models/ht_neuron.h | 26 +-- models/ht_synapse.h | 2 +- models/iaf_chs_2007.h | 20 +-- models/iaf_chxk_2008.cpp | 20 +-- models/iaf_cond_alpha.cpp | 20 +-- models/iaf_cond_alpha.h | 26 +-- models/iaf_cond_alpha_mc.cpp | 20 +-- models/iaf_cond_alpha_mc.h | 26 +-- models/iaf_cond_beta.cpp | 20 +-- models/iaf_cond_beta.h | 4 +- models/iaf_cond_exp.cpp | 20 +-- models/iaf_cond_exp.h | 26 +-- models/iaf_cond_exp_sfa_rr.h | 26 +-- models/iaf_psc_alpha.h | 24 +-- models/iaf_psc_alpha_canon.cpp | 1 - models/iaf_psc_alpha_canon.h | 26 +-- models/iaf_psc_alpha_ps.h | 26 +-- models/iaf_psc_delta.h | 24 +-- models/iaf_psc_delta_ps.cpp | 6 - models/iaf_psc_delta_ps.h | 26 +-- models/iaf_psc_exp.h | 24 +-- models/iaf_psc_exp_htum.h | 24 +-- models/iaf_psc_exp_multisynapse.cpp | 2 +- models/iaf_psc_exp_multisynapse.h | 24 +-- models/iaf_psc_exp_ps.h | 26 +-- models/iaf_psc_exp_ps_lossless.h | 26 +-- models/jonke_synapse.h | 2 +- models/mat2_psc_exp.h | 24 +-- models/modelsmodule.cpp | 2 +- models/multimeter.cpp | 6 +- models/multimeter.h | 22 +-- models/music_event_out_proxy.h | 2 +- models/music_rate_out_proxy.h | 2 +- models/parrot_neuron_ps.h | 18 +- models/pp_cond_exp_mc_urbanczik.h | 34 ++-- models/pp_pop_psc_delta.h | 24 +-- models/pp_psc_delta.h | 26 +-- models/rate_neuron_ipn.h | 28 ++-- models/rate_neuron_opn.h | 28 ++-- models/rate_transformer_node.h | 28 ++-- models/siegert_neuron.h | 24 +-- models/sinusoidal_poisson_generator.cpp | 2 - models/spin_detector.h | 26 +-- models/static_synapse.h | 16 +- models/static_synapse_hom_w.h | 16 +- models/stdp_dopamine_synapse.h | 6 +- models/stdp_nn_pre_centered_synapse.h | 2 +- models/stdp_nn_restr_synapse.h | 4 +- models/stdp_nn_symm_synapse.h | 2 +- models/stdp_pl_synapse_hom.h | 2 +- models/stdp_synapse.h | 2 +- models/stdp_synapse_facetshw_hom.h | 4 +- models/stdp_synapse_hom.h | 2 +- models/stdp_triplet_synapse.h | 2 +- models/tsodyks_synapse_hom.h | 2 +- models/urbanczik_synapse.h | 4 +- models/vogels_sprekeler_synapse.h | 2 +- models/volume_transmitter.h | 24 +-- nestkernel/archiving_node.h | 14 +- nestkernel/clopath_archiving_node.h | 8 +- nestkernel/common_synapse_properties.cpp | 2 +- nestkernel/conn_builder.h | 38 ++--- nestkernel/conn_builder_factory.h | 2 +- nestkernel/conn_parameter.h | 56 +++---- nestkernel/connection_manager.h | 10 +- nestkernel/connection_manager_impl.h | 2 +- nestkernel/connector_base.h | 42 ++--- nestkernel/connector_model.h | 26 +-- nestkernel/connector_model_impl.h | 4 +- nestkernel/dynamicloader.cpp | 10 +- nestkernel/dynamicloader.h | 10 +- nestkernel/event.cpp | 4 +- nestkernel/event.h | 84 +++++----- nestkernel/event_delivery_manager.h | 12 +- nestkernel/exceptions.h | 142 ++++++++-------- nestkernel/genericmodel.h | 38 ++--- nestkernel/grid_mask.h | 10 +- nestkernel/growth_curve.h | 18 +- nestkernel/io_manager.cpp | 2 +- nestkernel/layer.cpp | 6 +- nestkernel/layer.h | 34 ++-- nestkernel/logging_manager.cpp | 2 +- nestkernel/logging_manager.h | 8 +- nestkernel/mask.h | 52 +++--- nestkernel/model.cpp | 2 +- nestkernel/model.h | 4 +- nestkernel/model_manager.cpp | 8 +- nestkernel/model_manager.h | 4 +- nestkernel/model_manager_impl.h | 4 +- nestkernel/modelrange_manager.h | 2 +- nestkernel/mpi_manager.h | 2 +- nestkernel/nestmodule.cpp | 14 +- nestkernel/nestmodule.h | 204 +++++++++++------------ nestkernel/node.cpp | 4 - nestkernel/node.h | 2 +- nestkernel/node_collection.cpp | 2 +- nestkernel/node_collection.h | 2 +- nestkernel/node_manager.cpp | 14 +- nestkernel/node_manager.h | 2 +- nestkernel/proxynode.h | 32 ++-- nestkernel/pseudo_recording_device.h | 2 +- nestkernel/random_manager.h | 2 +- nestkernel/recording_backend_ascii.h | 2 +- nestkernel/recording_backend_memory.h | 2 +- nestkernel/recording_backend_screen.h | 2 +- nestkernel/simulation_manager.cpp | 4 +- nestkernel/sp_manager.cpp | 4 +- nestkernel/sp_manager_impl.h | 2 +- nestkernel/sparse_node_array.cpp | 4 +- nestkernel/spatial.h | 14 +- nestkernel/structural_plasticity_node.h | 20 +-- nestkernel/synaptic_element.cpp | 2 +- nestkernel/target_identifier.h | 4 +- nestkernel/target_table_devices.cpp | 8 +- nestkernel/target_table_devices_impl.h | 6 +- nestkernel/urbanczik_archiving_node.h | 18 +- nestkernel/vp_manager.h | 2 +- pynest/nest/versionchecker.py | 33 ++++ sli/allocator.cpp | 24 +-- sli/allocator.h | 20 +-- sli/booldatum.cc | 2 +- sli/booldatum.h | 8 +- sli/datum.h | 10 +- sli/dict.h | 4 +- sli/dictstack.cc | 8 +- sli/dictstack.h | 2 +- sli/dictutils.cc | 6 +- sli/dictutils.h | 4 +- sli/fdstream.cc | 20 +-- sli/fdstream.h | 32 ++-- sli/filesystem.cc | 34 ++-- sli/filesystem.h | 30 ++-- sli/genericdatum.h | 6 +- sli/gnureadline.h | 10 +- sli/interpret.cc | 12 +- sli/interpret.h | 28 ++-- sli/lockptrdatum.h | 4 +- sli/name.cc | 2 +- sli/name.h | 2 +- sli/namedatum.h | 14 +- sli/numericdatum.h | 4 +- sli/oosupport.cc | 10 +- sli/parser.cc | 16 +- sli/parser.h | 6 +- sli/parserdatum.h | 4 +- sli/processes.cc | 54 +++--- sli/processes.h | 46 ++--- sli/scanner.h | 2 +- sli/sharedptrdatum.h | 2 +- sli/sli_io.cc | 106 ++++++------ sli/sli_io.h | 92 +++++----- sli/sliactions.cc | 2 +- sli/sliactions.h | 18 +- sli/sliarray.h | 154 ++++++++--------- sli/slibuiltins.cc | 30 ++-- sli/slibuiltins.h | 36 ++-- sli/slicontrol.cc | 4 +- sli/slicontrol.h | 112 ++++++------- sli/slimath.cc | 2 +- sli/sliregexp.cc | 2 +- sli/specialfunctionsmodule.cc | 6 +- sli/specialfunctionsmodule.h | 22 +-- sli/stringdatum.h | 4 +- sli/symboldatum.h | 4 +- sli/tarrayobj.cc | 62 +++---- sli/token.cc | 1 - sli/token.h | 38 ++--- sli/tokenarray.cc | 16 +- sli/tokenarray.h | 30 ++-- sli/tokenstack.h | 16 +- sli/tokenutils.cc | 24 +-- sli/triedatum.cc | 2 +- sli/triedatum.h | 18 +- sli/typechk.cc | 34 ++-- sli/typechk.h | 24 +-- sli/utils.cc | 2 +- testsuite/cpptests/test_enum_bitfield.h | 2 +- 222 files changed, 2094 insertions(+), 2080 deletions(-) create mode 100644 pynest/nest/versionchecker.py diff --git a/.gitignore b/.gitignore index d6aa1cd756..a4aca41855 100644 --- a/.gitignore +++ b/.gitignore @@ -14,10 +14,6 @@ pynest/pynestkernel.cxx *.o *.pyc -Makefile - -build/ -install/ examples/example_logs/ /libnestutil/config.h diff --git a/doc/slidoc/index.html b/doc/slidoc/index.html index 7f0a316303..2164fddb38 100644 --- a/doc/slidoc/index.html +++ b/doc/slidoc/index.html @@ -54,7 +54,6 @@

NEST HelpDesk

Configuration and installation instructions (ext.) Introduction to the Python bindings for NEST (PyNEST) (ext.) Introduction to the simulation language SLI (ext.) - diff --git a/libnestutil/beta_normalization_factor.h b/libnestutil/beta_normalization_factor.h index 9f60060cb1..c722f38657 100644 --- a/libnestutil/beta_normalization_factor.h +++ b/libnestutil/beta_normalization_factor.h @@ -75,7 +75,7 @@ beta_normalization_factor( const double tau_rise, const double tau_decay ) { const double tau_difference = tau_decay - tau_rise; double peak_value = 0; - double normalization_factor = 0; + double normalization_factor; if ( std::abs( tau_difference ) > std::numeric_limits< double >::epsilon() ) { // peak time diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index 6fda456291..b6f0cc3de7 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -121,25 +121,25 @@ class lockPTR } D* - get( void ) const + get( ) const { return pointee; } bool - islocked( void ) const + islocked( ) const { return locked; } bool - isdeletable( void ) const + isdeletable( ) const { return deletable; } void - lock( void ) + lock( ) { assert( not locked ); #pragma omp atomic write // To avoid race conditions. @@ -147,7 +147,7 @@ class lockPTR } void - unlock( void ) + unlock( ) { assert( locked ); #pragma omp atomic write // To avoid race conditions. @@ -215,7 +215,7 @@ class lockPTR } D* - get( void ) + get( ) { assert( not obj->islocked() ); obj->lock(); // Try to lock Object @@ -223,7 +223,7 @@ class lockPTR } D* - get( void ) const + get( ) const { assert( not obj->islocked() ); @@ -296,49 +296,49 @@ class lockPTR bool - valid( void ) const //!< returns true if and only if obj->pointee != NULL + valid( ) const //!< returns true if and only if obj->pointee != NULL { assert( obj != NULL ); return ( obj->get() != NULL ); } bool - islocked( void ) const + islocked( ) const { assert( obj != NULL ); return ( obj->islocked() ); } bool - deletable( void ) const + deletable( ) const { assert( obj != NULL ); return ( obj->isdeletable() ); } void - lock( void ) const + lock( ) const { assert( obj != NULL ); obj->lock(); } void - unlock( void ) const + unlock( ) const { assert( obj != NULL ); obj->unlock(); } void - unlock( void ) + unlock( ) { assert( obj != NULL ); obj->unlock(); } size_t - references( void ) const + references( ) const { return ( obj == NULL ) ? 0 : obj.use_count(); } diff --git a/libnestutil/stopwatch.h b/libnestutil/stopwatch.h index 45fc06078c..410636f20d 100644 --- a/libnestutil/stopwatch.h +++ b/libnestutil/stopwatch.h @@ -281,7 +281,7 @@ nest::Stopwatch::get_timestamp() // * JuQueen (BG/Q) // * MacOS 10.9 struct timeval now; - gettimeofday( &now, ( struct timezone* ) 0 ); + gettimeofday( &now, ( struct timezone* ) nullptr ); return ( nest::Stopwatch::timestamp_t ) now.tv_usec + ( nest::Stopwatch::timestamp_t ) now.tv_sec * nest::Stopwatch::SECONDS; } diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index 38452412c4..ba7c23cf91 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -310,9 +310,9 @@ nest::aeif_cond_alpha::State_::set( const DictionaryDatum& d, const Parameters_& nest::aeif_cond_alpha::Buffers_::Buffers_( aeif_cond_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -320,9 +320,9 @@ nest::aeif_cond_alpha::Buffers_::Buffers_( aeif_cond_alpha& n ) nest::aeif_cond_alpha::Buffers_::Buffers_( const Buffers_&, aeif_cond_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -385,7 +385,7 @@ nest::aeif_cond_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -394,7 +394,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -403,7 +403,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -412,7 +412,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_cond_alpha_dynamics; diff --git a/models/aeif_cond_alpha.h b/models/aeif_cond_alpha.h index 608cef07ab..3559a62324 100644 --- a/models/aeif_cond_alpha.h +++ b/models/aeif_cond_alpha.h @@ -193,7 +193,7 @@ class aeif_cond_alpha : public ArchivingNode public: aeif_cond_alpha(); aeif_cond_alpha( const aeif_cond_alpha& ); - ~aeif_cond_alpha(); + ~aeif_cond_alpha() override; /** * Import sets of overloaded virtual functions. @@ -203,23 +203,23 @@ class aeif_cond_alpha : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index ce05088cd1..2d5e856b1a 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -338,9 +338,9 @@ aeif_cond_alpha_multisynapse::State_::set( const DictionaryDatum& d, Node* node aeif_cond_alpha_multisynapse::Buffers_::Buffers_( aeif_cond_alpha_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , IntegrationStep_( std::min( 0.01, step_ ) ) , I_stim_( 0.0 ) @@ -349,9 +349,9 @@ aeif_cond_alpha_multisynapse::Buffers_::Buffers_( aeif_cond_alpha_multisynapse& aeif_cond_alpha_multisynapse::Buffers_::Buffers_( const Buffers_& b, aeif_cond_alpha_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( b.step_ ) , IntegrationStep_( b.IntegrationStep_ ) , I_stim_( b.I_stim_ ) @@ -415,7 +415,7 @@ aeif_cond_alpha_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -427,7 +427,7 @@ aeif_cond_alpha_multisynapse::init_buffers_() // Stepping function and evolution function are allocated in pre_run_hook() B_.sys_.function = aeif_cond_alpha_multisynapse_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.params = reinterpret_cast< void* >( this ); // B_.sys_.dimension is assigned in pre_run_hook() B_.I_stim_ = 0.0; @@ -464,14 +464,14 @@ aeif_cond_alpha_multisynapse::pre_run_hook() State_::NUMBER_OF_FIXED_STATES_ELEMENTS + ( State_::NUM_STATE_ELEMENTS_PER_RECEPTOR * P_.n_receptors() ), 0.0 ); // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != 0 ) + if ( B_.s_ != nullptr ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != 0 ) + if ( B_.e_ != nullptr ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/aeif_cond_alpha_multisynapse.h b/models/aeif_cond_alpha_multisynapse.h index e296b6e518..737ae54f0e 100644 --- a/models/aeif_cond_alpha_multisynapse.h +++ b/models/aeif_cond_alpha_multisynapse.h @@ -191,23 +191,23 @@ class aeif_cond_alpha_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // The next three classes need to be friends to access the State_ class/member friend class DynamicRecordablesMap< aeif_cond_alpha_multisynapse >; diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index 9736ac5c95..d91f160e4c 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -346,9 +346,9 @@ aeif_cond_beta_multisynapse::State_::set( const DictionaryDatum& d, Node* node ) aeif_cond_beta_multisynapse::Buffers_::Buffers_( aeif_cond_beta_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , IntegrationStep_( std::min( 0.01, step_ ) ) , I_stim_( 0.0 ) @@ -357,9 +357,9 @@ aeif_cond_beta_multisynapse::Buffers_::Buffers_( aeif_cond_beta_multisynapse& n aeif_cond_beta_multisynapse::Buffers_::Buffers_( const Buffers_& b, aeif_cond_beta_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( b.step_ ) , IntegrationStep_( b.IntegrationStep_ ) , I_stim_( b.I_stim_ ) @@ -423,7 +423,7 @@ aeif_cond_beta_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -435,7 +435,7 @@ aeif_cond_beta_multisynapse::init_buffers_() // Stepping function and evolution function are allocated in pre_run_hook() B_.sys_.function = aeif_cond_beta_multisynapse_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.params = reinterpret_cast< void* >( this ); // B_.sys_.dimension is assigned in pre_run_hook() B_.I_stim_ = 0.0; @@ -473,14 +473,14 @@ aeif_cond_beta_multisynapse::pre_run_hook() State_::NUMBER_OF_FIXED_STATES_ELEMENTS + ( State_::NUM_STATE_ELEMENTS_PER_RECEPTOR * P_.n_receptors() ), 0.0 ); // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != 0 ) + if ( B_.s_ != nullptr ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != 0 ) + if ( B_.e_ != nullptr ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/aeif_cond_beta_multisynapse.h b/models/aeif_cond_beta_multisynapse.h index 5b132d57a0..25f1eb3cd7 100644 --- a/models/aeif_cond_beta_multisynapse.h +++ b/models/aeif_cond_beta_multisynapse.h @@ -194,23 +194,23 @@ class aeif_cond_beta_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // The next three classes need to be friends to access the State_ class/member friend class DynamicRecordablesMap< aeif_cond_beta_multisynapse >; diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index 9ced5680e1..290e9cd49b 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -305,9 +305,9 @@ nest::aeif_cond_exp::State_::set( const DictionaryDatum& d, const Parameters_&, nest::aeif_cond_exp::Buffers_::Buffers_( aeif_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -315,9 +315,9 @@ nest::aeif_cond_exp::Buffers_::Buffers_( aeif_cond_exp& n ) nest::aeif_cond_exp::Buffers_::Buffers_( const Buffers_&, aeif_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -380,7 +380,7 @@ nest::aeif_cond_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -389,7 +389,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -398,7 +398,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -407,7 +407,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_cond_exp_dynamics; diff --git a/models/aeif_cond_exp.h b/models/aeif_cond_exp.h index dc7b21d8ce..0c190cdb29 100644 --- a/models/aeif_cond_exp.h +++ b/models/aeif_cond_exp.h @@ -194,7 +194,7 @@ class aeif_cond_exp : public ArchivingNode public: aeif_cond_exp(); aeif_cond_exp( const aeif_cond_exp& ); - ~aeif_cond_exp(); + ~aeif_cond_exp() override; /** * Import sets of overloaded virtual functions. @@ -204,23 +204,23 @@ class aeif_cond_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( const Time&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( const Time&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index c4bd15cc15..9cd64d4723 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -300,9 +300,9 @@ nest::aeif_psc_alpha::State_::set( const DictionaryDatum& d, const Parameters_&, nest::aeif_psc_alpha::Buffers_::Buffers_( aeif_psc_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -310,9 +310,9 @@ nest::aeif_psc_alpha::Buffers_::Buffers_( aeif_psc_alpha& n ) nest::aeif_psc_alpha::Buffers_::Buffers_( const Buffers_&, aeif_psc_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -375,7 +375,7 @@ nest::aeif_psc_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -384,7 +384,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -393,7 +393,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -402,7 +402,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_psc_alpha_dynamics; diff --git a/models/aeif_psc_delta.h b/models/aeif_psc_delta.h index 7d7fb88f06..94a69fdd3e 100644 --- a/models/aeif_psc_delta.h +++ b/models/aeif_psc_delta.h @@ -174,7 +174,7 @@ class aeif_psc_delta : public ArchivingNode public: aeif_psc_delta(); aeif_psc_delta( const aeif_psc_delta& ); - ~aeif_psc_delta(); + ~aeif_psc_delta() override; /** * Import sets of overloaded virtual functions. @@ -184,23 +184,23 @@ class aeif_psc_delta : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( const Time&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( const Time&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index 31aafd95b5..d0cc52ab8c 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -344,9 +344,9 @@ nest::aeif_psc_delta_clopath::State_::set( const DictionaryDatum& d, const Param nest::aeif_psc_delta_clopath::Buffers_::Buffers_( aeif_psc_delta_clopath& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -354,9 +354,9 @@ nest::aeif_psc_delta_clopath::Buffers_::Buffers_( aeif_psc_delta_clopath& n ) nest::aeif_psc_delta_clopath::Buffers_::Buffers_( const Buffers_&, aeif_psc_delta_clopath& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -418,7 +418,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -426,7 +426,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -435,7 +435,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -444,7 +444,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_psc_delta_clopath_dynamics; diff --git a/models/aeif_psc_delta_clopath.h b/models/aeif_psc_delta_clopath.h index 0a35f13c1f..5d2bb376c4 100644 --- a/models/aeif_psc_delta_clopath.h +++ b/models/aeif_psc_delta_clopath.h @@ -204,7 +204,7 @@ class aeif_psc_delta_clopath : public ClopathArchivingNode public: aeif_psc_delta_clopath(); aeif_psc_delta_clopath( const aeif_psc_delta_clopath& ); - ~aeif_psc_delta_clopath(); + ~aeif_psc_delta_clopath() override; /** * Import sets of overloaded virtual functions. @@ -214,23 +214,23 @@ class aeif_psc_delta_clopath : public ClopathArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( const Time&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( const Time&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/aeif_psc_exp.h b/models/aeif_psc_exp.h index 5d81e5a725..4445b0e1cd 100644 --- a/models/aeif_psc_exp.h +++ b/models/aeif_psc_exp.h @@ -181,7 +181,7 @@ class aeif_psc_exp : public ArchivingNode public: aeif_psc_exp(); aeif_psc_exp( const aeif_psc_exp& ); - ~aeif_psc_exp(); + ~aeif_psc_exp() override; /** * Import sets of overloaded virtual functions. @@ -191,23 +191,23 @@ class aeif_psc_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( const Time&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( const Time&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/amat2_psc_exp.h b/models/amat2_psc_exp.h index b2bd75ef61..7839e403c3 100644 --- a/models/amat2_psc_exp.h +++ b/models/amat2_psc_exp.h @@ -175,23 +175,23 @@ class amat2_psc_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access private members friend class RecordablesMap< amat2_psc_exp >; diff --git a/models/binary_neuron.h b/models/binary_neuron.h index 953a352c2a..54ab5f1aef 100644 --- a/models/binary_neuron.h +++ b/models/binary_neuron.h @@ -94,34 +94,34 @@ class binary_neuron : public ArchivingNode using Node::receives_signal; using Node::sends_signal; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - SignalType sends_signal() const; - SignalType receives_signal() const; + SignalType sends_signal() const override; + SignalType receives_signal() const override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; // gain function functor // must have an double operator(double) defined TGainfunction gain_; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< binary_neuron< TGainfunction > >; diff --git a/models/clopath_synapse.h b/models/clopath_synapse.h index fc181d9636..50eed6d796 100644 --- a/models/clopath_synapse.h +++ b/models/clopath_synapse.h @@ -164,7 +164,7 @@ class clopath_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/cm_default.h b/models/cm_default.h index d7e4751b0e..f466ee4755 100644 --- a/models/cm_default.h +++ b/models/cm_default.h @@ -235,27 +235,27 @@ class cm_default : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: void add_compartment_( DictionaryDatum& dd ); void add_receptor_( DictionaryDatum& dd ); void init_recordables_pointers_(); - void pre_run_hook(); + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; CompTree c_tree_; std::vector< RingBuffer > syn_buffers_; diff --git a/models/cont_delay_synapse.h b/models/cont_delay_synapse.h index 63c33827e7..b4cafc83a8 100644 --- a/models/cont_delay_synapse.h +++ b/models/cont_delay_synapse.h @@ -145,42 +145,42 @@ class cont_delay_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( RateEvent&, rport ) + handles_test_event( RateEvent&, rport ) override { return invalid_port; } port - handles_test_event( DataLoggingRequest&, rport ) + handles_test_event( DataLoggingRequest&, rport ) override { return invalid_port; } port - handles_test_event( CurrentEvent&, rport ) + handles_test_event( CurrentEvent&, rport ) override { return invalid_port; } port - handles_test_event( ConductanceEvent&, rport ) + handles_test_event( ConductanceEvent&, rport ) override { return invalid_port; } port - handles_test_event( DoubleDataEvent&, rport ) + handles_test_event( DoubleDataEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSSpikeEvent&, rport ) + handles_test_event( DSSpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSCurrentEvent&, rport ) + handles_test_event( DSCurrentEvent&, rport ) override { return invalid_port; } diff --git a/models/correlation_detector.h b/models/correlation_detector.h index b6fbd70d03..d6008c4af6 100644 --- a/models/correlation_detector.h +++ b/models/correlation_detector.h @@ -169,13 +169,13 @@ class correlation_detector : public Node * spikes also from sources which live on other threads. */ bool - has_proxies() const + has_proxies() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -188,21 +188,21 @@ class correlation_detector : public Node using Node::handle; using Node::handles_test_event; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; private: - void init_state_(); - void init_buffers_(); - void pre_run_hook(); + void init_state_() override; + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // ------------------------------------------------------------ diff --git a/models/correlomatrix_detector.h b/models/correlomatrix_detector.h index bcf9cdba5f..d66719aa4d 100644 --- a/models/correlomatrix_detector.h +++ b/models/correlomatrix_detector.h @@ -159,13 +159,13 @@ class correlomatrix_detector : public Node * spikes also from sources which live on other threads. */ bool - has_proxies() const + has_proxies() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -178,21 +178,21 @@ class correlomatrix_detector : public Node using Node::handle; using Node::handles_test_event; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; private: - void init_state_(); - void init_buffers_(); - void pre_run_hook(); + void init_state_() override; + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // ------------------------------------------------------------ @@ -323,7 +323,7 @@ correlomatrix_detector::set_status( const DictionaryDatum& d ) device_.set_status( d ); P_ = ptmp; - if ( reset_required == true ) + if ( reset_required ) { S_.reset( P_ ); } diff --git a/models/correlospinmatrix_detector.h b/models/correlospinmatrix_detector.h index 23bad2fd43..7e697d9182 100644 --- a/models/correlospinmatrix_detector.h +++ b/models/correlospinmatrix_detector.h @@ -140,13 +140,13 @@ class correlospinmatrix_detector : public Node * spikes also from sources which live on other threads. */ bool - has_proxies() const + has_proxies() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -160,23 +160,23 @@ class correlospinmatrix_detector : public Node using Node::handles_test_event; using Node::receives_signal; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - SignalType receives_signal() const; + SignalType receives_signal() const override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; private: - void init_state_(); - void init_buffers_(); - void pre_run_hook(); + void init_state_() override; + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // ------------------------------------------------------------ @@ -319,7 +319,7 @@ correlospinmatrix_detector::set_status( const DictionaryDatum& d ) device_.set_status( d ); P_ = ptmp; - if ( reset_required == true ) + if ( reset_required ) { S_.reset( P_ ); } diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index 248b76d8eb..2d7d5fbc78 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -338,9 +338,9 @@ nest::gif_cond_exp::State_::set( const DictionaryDatum& d, const Parameters_&, N nest::gif_cond_exp::Buffers_::Buffers_( gif_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -348,9 +348,9 @@ nest::gif_cond_exp::Buffers_::Buffers_( gif_cond_exp& n ) nest::gif_cond_exp::Buffers_::Buffers_( const Buffers_&, gif_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -410,7 +410,7 @@ nest::gif_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -419,7 +419,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -428,7 +428,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -438,7 +438,7 @@ nest::gif_cond_exp::init_buffers_() } B_.sys_.function = gif_cond_exp_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); } diff --git a/models/gif_cond_exp_multisynapse.h b/models/gif_cond_exp_multisynapse.h index cd9305aaeb..b3432170ad 100644 --- a/models/gif_cond_exp_multisynapse.h +++ b/models/gif_cond_exp_multisynapse.h @@ -219,7 +219,7 @@ class gif_cond_exp_multisynapse : public ArchivingNode public: gif_cond_exp_multisynapse(); gif_cond_exp_multisynapse( const gif_cond_exp_multisynapse& ); - ~gif_cond_exp_multisynapse(); + ~gif_cond_exp_multisynapse() override; /** * Import sets of overloaded virtual functions. @@ -229,25 +229,25 @@ class gif_cond_exp_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // make dynamics function quasi-member friend int gif_cond_exp_multisynapse_dynamics( double, const double*, double*, void* ); diff --git a/models/gif_pop_psc_exp.h b/models/gif_pop_psc_exp.h index 5380320b4a..c9ed016acf 100644 --- a/models/gif_pop_psc_exp.h +++ b/models/gif_pop_psc_exp.h @@ -172,24 +172,24 @@ class gif_pop_psc_exp : public Node using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; double escrate( const double ); long draw_poisson( const double n_expect_ ); diff --git a/models/gif_psc_exp_multisynapse.h b/models/gif_psc_exp_multisynapse.h index f9526a520a..6f3405ff71 100644 --- a/models/gif_psc_exp_multisynapse.h +++ b/models/gif_psc_exp_multisynapse.h @@ -220,24 +220,24 @@ class gif_psc_exp_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< gif_psc_exp_multisynapse >; diff --git a/models/ginzburg_neuron.h b/models/ginzburg_neuron.h index cc353796d4..e9a81499b5 100644 --- a/models/ginzburg_neuron.h +++ b/models/ginzburg_neuron.h @@ -162,11 +162,11 @@ class gainfunction_ginzburg void get( DictionaryDatum& ) const; //!< Store current values in dictionary void set( const DictionaryDatum&, Node* node ); //!< Set values from dicitonary - bool operator()( RngPtr rng, double h ); + bool operator()( RngPtr rng, double h ) const; }; inline bool -gainfunction_ginzburg::operator()( RngPtr rng, double h ) +gainfunction_ginzburg::operator()( RngPtr rng, double h ) const { return rng->drand() < c1_ * h + c2_ * 0.5 * ( 1.0 + tanh( c3_ * ( h - theta_ ) ) ); } diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 0b48ea9253..36d76eaefc 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -372,7 +372,7 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) + "), must have the same size." ); } - if ( this->n_receptors_() != old_n_receptors && has_connections_ == true ) + if ( this->n_receptors_() != old_n_receptors && has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " @@ -455,9 +455,9 @@ nest::glif_cond::State_::set( const DictionaryDatum& d, const Parameters_& p, do nest::glif_cond::Buffers_::Buffers_( glif_cond& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , IntegrationStep_( std::min( 0.01, step_ ) ) , I_( 0.0 ) @@ -466,9 +466,9 @@ nest::glif_cond::Buffers_::Buffers_( glif_cond& n ) nest::glif_cond::Buffers_::Buffers_( const Buffers_& b, glif_cond& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( b.step_ ) , IntegrationStep_( b.IntegrationStep_ ) , I_( b.I_ ) @@ -531,7 +531,7 @@ nest::glif_cond::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -541,7 +541,7 @@ nest::glif_cond::init_buffers_() } B_.sys_.function = glif_cond_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.params = reinterpret_cast< void* >( this ); B_.I_ = 0.0; @@ -596,14 +596,14 @@ nest::glif_cond::pre_run_hook() } // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != 0 ) + if ( B_.s_ != nullptr ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != 0 ) + if ( B_.e_ != nullptr ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/glif_cond.h b/models/glif_cond.h index 5d386a30a5..d5fe23ff05 100644 --- a/models/glif_cond.h +++ b/models/glif_cond.h @@ -201,33 +201,33 @@ class glif_cond : public nest::ArchivingNode glif_cond( const glif_cond& ); - ~glif_cond(); + ~glif_cond() override; using nest::Node::handle; using nest::Node::handles_test_event; - nest::port send_test_event( nest::Node&, nest::port, nest::synindex, bool ); + nest::port send_test_event( nest::Node&, nest::port, nest::synindex, bool ) override; - void handle( nest::SpikeEvent& ); - void handle( nest::CurrentEvent& ); - void handle( nest::DataLoggingRequest& ); + void handle( nest::SpikeEvent& ) override; + void handle( nest::CurrentEvent& ) override; + void handle( nest::DataLoggingRequest& ) override; - nest::port handles_test_event( nest::SpikeEvent&, nest::port ); - nest::port handles_test_event( nest::CurrentEvent&, nest::port ); - nest::port handles_test_event( nest::DataLoggingRequest&, nest::port ); + nest::port handles_test_event( nest::SpikeEvent&, nest::port ) override; + nest::port handles_test_event( nest::CurrentEvent&, nest::port ) override; + nest::port handles_test_event( nest::DataLoggingRequest&, nest::port ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: //! Reset internal buffers of neuron. - void init_buffers_(); + void init_buffers_() override; //! Initialize auxiliary quantities, leave parameters and state untouched. - void pre_run_hook(); + void pre_run_hook() override; //! Take neuron through given time interval - void update( nest::Time const&, const long, const long ); + void update( nest::Time const&, const long, const long ) override; // make dynamics function quasi-member friend int glif_cond_dynamics( double, const double*, double*, void* ); diff --git a/models/glif_psc.cpp b/models/glif_psc.cpp index cbe7ddae00..97e26b8c45 100644 --- a/models/glif_psc.cpp +++ b/models/glif_psc.cpp @@ -283,7 +283,7 @@ nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) const size_t old_n_receptors = this->n_receptors_(); if ( updateValue< std::vector< double > >( d, names::tau_syn, tau_syn_ ) ) { - if ( this->n_receptors_() != old_n_receptors && has_connections_ == true ) + if ( this->n_receptors_() != old_n_receptors && has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " diff --git a/models/glif_psc.h b/models/glif_psc.h index 551ebc0d16..d122ae6969 100644 --- a/models/glif_psc.h +++ b/models/glif_psc.h @@ -201,28 +201,28 @@ class glif_psc : public nest::ArchivingNode using nest::Node::handle; using nest::Node::handles_test_event; - nest::port send_test_event( nest::Node&, nest::port, nest::synindex, bool ); + nest::port send_test_event( nest::Node&, nest::port, nest::synindex, bool ) override; - void handle( nest::SpikeEvent& ); - void handle( nest::CurrentEvent& ); - void handle( nest::DataLoggingRequest& ); + void handle( nest::SpikeEvent& ) override; + void handle( nest::CurrentEvent& ) override; + void handle( nest::DataLoggingRequest& ) override; - nest::port handles_test_event( nest::SpikeEvent&, nest::port ); - nest::port handles_test_event( nest::CurrentEvent&, nest::port ); - nest::port handles_test_event( nest::DataLoggingRequest&, nest::port ); + nest::port handles_test_event( nest::SpikeEvent&, nest::port ) override; + nest::port handles_test_event( nest::CurrentEvent&, nest::port ) override; + nest::port handles_test_event( nest::DataLoggingRequest&, nest::port ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: //! Reset internal buffers of neuron. - void init_buffers_(); + void init_buffers_() override; //! Initialize auxiliary quantities, leave parameters and state untouched. - void pre_run_hook(); + void pre_run_hook() override; //! Take neuron through given time interval - void update( nest::Time const&, const long, const long ); + void update( nest::Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class nest::RecordablesMap< glif_psc >; diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index 97f6a29604..f759d715b2 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -313,9 +313,9 @@ nest::hh_cond_beta_gap_traub::State_::set( const DictionaryDatum& d, const Param nest::hh_cond_beta_gap_traub::Buffers_::Buffers_( hh_cond_beta_gap_traub& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -323,9 +323,9 @@ nest::hh_cond_beta_gap_traub::Buffers_::Buffers_( hh_cond_beta_gap_traub& n ) nest::hh_cond_beta_gap_traub::Buffers_::Buffers_( const Buffers_&, hh_cond_beta_gap_traub& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -408,7 +408,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -417,7 +417,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -426,7 +426,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -436,7 +436,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() } B_.sys_.function = hh_cond_beta_gap_traub_dynamics; - B_.sys_.jacobian = 0; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/hh_cond_beta_gap_traub.h b/models/hh_cond_beta_gap_traub.h index 7d60f8dd52..ea4d42d329 100644 --- a/models/hh_cond_beta_gap_traub.h +++ b/models/hh_cond_beta_gap_traub.h @@ -180,7 +180,7 @@ class hh_cond_beta_gap_traub : public ArchivingNode hh_cond_beta_gap_traub(); hh_cond_beta_gap_traub( const hh_cond_beta_gap_traub& ); - ~hh_cond_beta_gap_traub(); + ~hh_cond_beta_gap_traub() override; /** * Import sets of overloaded virtual functions. @@ -191,30 +191,30 @@ class hh_cond_beta_gap_traub : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - port send_test_event( Node& target, rport receptor_type, synindex, bool ); + port send_test_event( Node& target, rport receptor_type, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); - void handle( GapJunctionEvent& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; + void handle( GapJunctionEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); - port handles_test_event( GapJunctionEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; + port handles_test_event( GapJunctionEvent&, rport ) override; void - sends_secondary_event( GapJunctionEvent& ) + sends_secondary_event( GapJunctionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); + void init_buffers_() override; double get_normalisation_factor( double, double ); - void pre_run_hook(); + void pre_run_hook() override; /** This is the actual update function. The additional boolean parameter * determines if the function is called by update (false) or wfr_update (true) diff --git a/models/hh_cond_exp_traub.h b/models/hh_cond_exp_traub.h index f112953d8c..36b55e5d7f 100644 --- a/models/hh_cond_exp_traub.h +++ b/models/hh_cond_exp_traub.h @@ -152,7 +152,7 @@ class hh_cond_exp_traub : public ArchivingNode public: hh_cond_exp_traub(); hh_cond_exp_traub( const hh_cond_exp_traub& ); - ~hh_cond_exp_traub(); + ~hh_cond_exp_traub() override; /** * Import sets of overloaded virtual functions. @@ -162,24 +162,24 @@ class hh_cond_exp_traub : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index d2eddb4343..bb83db9efa 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -261,9 +261,9 @@ nest::hh_psc_alpha::State_::set( const DictionaryDatum& d, Node* node ) nest::hh_psc_alpha::Buffers_::Buffers_( hh_psc_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -271,9 +271,9 @@ nest::hh_psc_alpha::Buffers_::Buffers_( hh_psc_alpha& n ) nest::hh_psc_alpha::Buffers_::Buffers_( const Buffers_&, hh_psc_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -334,7 +334,7 @@ nest::hh_psc_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -343,7 +343,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -352,7 +352,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -362,7 +362,7 @@ nest::hh_psc_alpha::init_buffers_() } B_.sys_.function = hh_psc_alpha_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/hh_psc_alpha.h b/models/hh_psc_alpha.h index 9ed8086ef0..4bae67bb70 100644 --- a/models/hh_psc_alpha.h +++ b/models/hh_psc_alpha.h @@ -148,7 +148,7 @@ class hh_psc_alpha : public ArchivingNode public: hh_psc_alpha(); hh_psc_alpha( const hh_psc_alpha& ); - ~hh_psc_alpha(); + ~hh_psc_alpha() override; /** * Import sets of overloaded virtual functions. @@ -158,23 +158,23 @@ class hh_psc_alpha : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index 02ec008e07..659d03030a 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -287,9 +287,9 @@ nest::hh_psc_alpha_clopath::State_::set( const DictionaryDatum& d, Node* node ) nest::hh_psc_alpha_clopath::Buffers_::Buffers_( hh_psc_alpha_clopath& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -297,9 +297,9 @@ nest::hh_psc_alpha_clopath::Buffers_::Buffers_( hh_psc_alpha_clopath& n ) nest::hh_psc_alpha_clopath::Buffers_::Buffers_( const Buffers_&, hh_psc_alpha_clopath& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -360,7 +360,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -369,7 +369,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -378,7 +378,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -388,7 +388,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() } B_.sys_.function = hh_psc_alpha_clopath_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/hh_psc_alpha_clopath.h b/models/hh_psc_alpha_clopath.h index 5e6ea307ad..22166f4e1b 100644 --- a/models/hh_psc_alpha_clopath.h +++ b/models/hh_psc_alpha_clopath.h @@ -186,7 +186,7 @@ class hh_psc_alpha_clopath : public ClopathArchivingNode public: hh_psc_alpha_clopath(); hh_psc_alpha_clopath( const hh_psc_alpha_clopath& ); - ~hh_psc_alpha_clopath(); + ~hh_psc_alpha_clopath() override; /** * Import sets of overloaded virtual functions. @@ -196,23 +196,23 @@ class hh_psc_alpha_clopath : public ClopathArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index 362449ff56..d4656e97cb 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -303,9 +303,9 @@ nest::hh_psc_alpha_gap::State_::set( const DictionaryDatum& d, Node* node ) nest::hh_psc_alpha_gap::Buffers_::Buffers_( hh_psc_alpha_gap& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -313,9 +313,9 @@ nest::hh_psc_alpha_gap::Buffers_::Buffers_( hh_psc_alpha_gap& n ) nest::hh_psc_alpha_gap::Buffers_::Buffers_( const Buffers_&, hh_psc_alpha_gap& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -398,7 +398,7 @@ nest::hh_psc_alpha_gap::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -407,7 +407,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-6, 0.0 ); } @@ -416,7 +416,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-6, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -426,7 +426,7 @@ nest::hh_psc_alpha_gap::init_buffers_() } B_.sys_.function = hh_psc_alpha_gap_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/hh_psc_alpha_gap.h b/models/hh_psc_alpha_gap.h index 86ba354698..6bf15259c2 100644 --- a/models/hh_psc_alpha_gap.h +++ b/models/hh_psc_alpha_gap.h @@ -158,7 +158,7 @@ class hh_psc_alpha_gap : public ArchivingNode hh_psc_alpha_gap(); hh_psc_alpha_gap( const hh_psc_alpha_gap& ); - ~hh_psc_alpha_gap(); + ~hh_psc_alpha_gap() override; /** * Import sets of overloaded virtual functions. @@ -169,36 +169,36 @@ class hh_psc_alpha_gap : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - port send_test_event( Node& target, rport receptor_type, synindex, bool ); + port send_test_event( Node& target, rport receptor_type, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); - void handle( GapJunctionEvent& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; + void handle( GapJunctionEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); - port handles_test_event( GapJunctionEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; + port handles_test_event( GapJunctionEvent&, rport ) override; void - sends_secondary_event( GapJunctionEvent& ) + sends_secondary_event( GapJunctionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** This is the actual update function. The additional boolean parameter * determines if the function is called by update (false) or wfr_update (true) */ bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; bool wfr_update( Time const&, const long, const long ); // END Boilerplate function declarations ---------------------------- diff --git a/models/ht_neuron.cpp b/models/ht_neuron.cpp index 2eb3e68081..732706ce09 100644 --- a/models/ht_neuron.cpp +++ b/models/ht_neuron.cpp @@ -582,9 +582,9 @@ nest::ht_neuron::State_::set( const DictionaryDatum& d, const ht_neuron& node, N nest::ht_neuron::Buffers_::Buffers_( ht_neuron& n ) : logger_( n ) , spike_inputs_( std::vector< RingBuffer >( SUP_SPIKE_RECEPTOR - 1 ) ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , integration_step_( step_ ) , I_stim_( 0.0 ) @@ -594,9 +594,9 @@ nest::ht_neuron::Buffers_::Buffers_( ht_neuron& n ) nest::ht_neuron::Buffers_::Buffers_( const Buffers_&, ht_neuron& n ) : logger_( n ) , spike_inputs_( std::vector< RingBuffer >( SUP_SPIKE_RECEPTOR - 1 ) ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , integration_step_( step_ ) , I_stim_( 0.0 ) @@ -663,7 +663,7 @@ nest::ht_neuron::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.integration_step_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -672,7 +672,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -681,7 +681,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -691,7 +691,7 @@ nest::ht_neuron::init_buffers_() } B_.sys_.function = ht_neuron_dynamics; - B_.sys_.jacobian = 0; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/ht_neuron.h b/models/ht_neuron.h index 7e56f4a15a..d2a2936a62 100644 --- a/models/ht_neuron.h +++ b/models/ht_neuron.h @@ -187,7 +187,7 @@ class ht_neuron : public ArchivingNode public: ht_neuron(); ht_neuron( const ht_neuron& ); - ~ht_neuron(); + ~ht_neuron() override; /** * Import sets of overloaded virtual functions. @@ -197,18 +197,18 @@ class ht_neuron : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& e ); - void handle( CurrentEvent& e ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& e ) override; + void handle( CurrentEvent& e ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: /** @@ -226,10 +226,10 @@ class ht_neuron : public ArchivingNode SUP_SPIKE_RECEPTOR }; - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; double get_synapse_constant( double, double, double ); diff --git a/models/ht_synapse.h b/models/ht_synapse.h index a4016fbc97..410446a293 100644 --- a/models/ht_synapse.h +++ b/models/ht_synapse.h @@ -151,7 +151,7 @@ class ht_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/iaf_chs_2007.h b/models/iaf_chs_2007.h index 51a2720f14..3a48066180 100644 --- a/models/iaf_chs_2007.h +++ b/models/iaf_chs_2007.h @@ -125,22 +125,22 @@ class iaf_chs_2007 : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( const Time&, const long, const long ); + void update( const Time&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< iaf_chs_2007 >; diff --git a/models/iaf_chxk_2008.cpp b/models/iaf_chxk_2008.cpp index 24dcffc469..b69e7174a0 100644 --- a/models/iaf_chxk_2008.cpp +++ b/models/iaf_chxk_2008.cpp @@ -171,9 +171,9 @@ nest::iaf_chxk_2008::State_::operator=( const State_& s ) nest::iaf_chxk_2008::Buffers_::Buffers_( iaf_chxk_2008& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -181,9 +181,9 @@ nest::iaf_chxk_2008::Buffers_::Buffers_( iaf_chxk_2008& n ) nest::iaf_chxk_2008::Buffers_::Buffers_( const Buffers_&, iaf_chxk_2008& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -305,7 +305,7 @@ nest::iaf_chxk_2008::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -314,7 +314,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -323,7 +323,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -333,7 +333,7 @@ nest::iaf_chxk_2008::init_buffers_() } B_.sys_.function = iaf_chxk_2008_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index f6e12f3b22..86df34a52a 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -166,9 +166,9 @@ nest::iaf_cond_alpha::State_::operator=( const State_& s ) nest::iaf_cond_alpha::Buffers_::Buffers_( iaf_cond_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -176,9 +176,9 @@ nest::iaf_cond_alpha::Buffers_::Buffers_( iaf_cond_alpha& n ) nest::iaf_cond_alpha::Buffers_::Buffers_( const Buffers_&, iaf_cond_alpha& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -318,7 +318,7 @@ nest::iaf_cond_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -327,7 +327,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -336,7 +336,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -346,7 +346,7 @@ nest::iaf_cond_alpha::init_buffers_() } B_.sys_.function = iaf_cond_alpha_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/iaf_cond_alpha.h b/models/iaf_cond_alpha.h index f3ca2ffb2e..2a077c50b8 100644 --- a/models/iaf_cond_alpha.h +++ b/models/iaf_cond_alpha.h @@ -137,7 +137,7 @@ class iaf_cond_alpha : public ArchivingNode public: iaf_cond_alpha(); iaf_cond_alpha( const iaf_cond_alpha& ); - ~iaf_cond_alpha(); + ~iaf_cond_alpha() override; /* * Import all overloaded virtual functions that we @@ -148,23 +148,23 @@ class iaf_cond_alpha : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node& tagret, rport receptor_type, synindex, bool ); + port send_test_event( Node& tagret, rport receptor_type, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index cd73b2baa3..425def4ede 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -314,9 +314,9 @@ nest::iaf_cond_alpha_mc::State_::operator=( const State_& s ) nest::iaf_cond_alpha_mc::Buffers_::Buffers_( iaf_cond_alpha_mc& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -324,9 +324,9 @@ nest::iaf_cond_alpha_mc::Buffers_::Buffers_( iaf_cond_alpha_mc& n ) nest::iaf_cond_alpha_mc::Buffers_::Buffers_( const Buffers_&, iaf_cond_alpha_mc& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -515,7 +515,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -524,7 +524,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -533,7 +533,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -543,7 +543,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() } B_.sys_.function = iaf_cond_alpha_mc_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); for ( size_t n = 0; n < NCOMP; ++n ) diff --git a/models/iaf_cond_alpha_mc.h b/models/iaf_cond_alpha_mc.h index 3404d31c5e..6fb829d7ab 100644 --- a/models/iaf_cond_alpha_mc.h +++ b/models/iaf_cond_alpha_mc.h @@ -178,7 +178,7 @@ class iaf_cond_alpha_mc : public ArchivingNode public: iaf_cond_alpha_mc(); iaf_cond_alpha_mc( const iaf_cond_alpha_mc& ); - ~iaf_cond_alpha_mc(); + ~iaf_cond_alpha_mc() override; /** * Import sets of overloaded virtual functions. @@ -188,23 +188,23 @@ class iaf_cond_alpha_mc : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // Enumerations and constants specifying structure and properties ---- diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index c7d88155d3..c5b51c3464 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -169,9 +169,9 @@ nest::iaf_cond_beta::State_::operator=( const State_& s ) nest::iaf_cond_beta::Buffers_::Buffers_( iaf_cond_beta& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -179,9 +179,9 @@ nest::iaf_cond_beta::Buffers_::Buffers_( iaf_cond_beta& n ) nest::iaf_cond_beta::Buffers_::Buffers_( const Buffers_&, iaf_cond_beta& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -325,7 +325,7 @@ nest::iaf_cond_beta::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -334,7 +334,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -343,7 +343,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -353,7 +353,7 @@ nest::iaf_cond_beta::init_buffers_() } B_.sys_.function = iaf_cond_beta_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/iaf_cond_beta.h b/models/iaf_cond_beta.h index 785abcc131..4ac4e15251 100644 --- a/models/iaf_cond_beta.h +++ b/models/iaf_cond_beta.h @@ -437,6 +437,6 @@ iaf_cond_beta::set_status( const DictionaryDatum& d ) } // namespace -#endif // IAF_COND_BETA_H - #endif // HAVE_GSL + +#endif // IAF_COND_BETA_H diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index 4fe51d41bc..63ac115d68 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -223,9 +223,9 @@ nest::iaf_cond_exp::State_::set( const DictionaryDatum& d, const Parameters_&, N nest::iaf_cond_exp::Buffers_::Buffers_( iaf_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -233,9 +233,9 @@ nest::iaf_cond_exp::Buffers_::Buffers_( iaf_cond_exp& n ) nest::iaf_cond_exp::Buffers_::Buffers_( const Buffers_&, iaf_cond_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -296,7 +296,7 @@ nest::iaf_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -305,7 +305,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -314,7 +314,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -324,7 +324,7 @@ nest::iaf_cond_exp::init_buffers_() } B_.sys_.function = iaf_cond_exp_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/iaf_cond_exp.h b/models/iaf_cond_exp.h index e535d11545..20d7c5a0b3 100644 --- a/models/iaf_cond_exp.h +++ b/models/iaf_cond_exp.h @@ -128,7 +128,7 @@ class iaf_cond_exp : public ArchivingNode public: iaf_cond_exp(); iaf_cond_exp( const iaf_cond_exp& ); - ~iaf_cond_exp(); + ~iaf_cond_exp() override; /** * Import sets of overloaded virtual functions. @@ -138,23 +138,23 @@ class iaf_cond_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/iaf_cond_exp_sfa_rr.h b/models/iaf_cond_exp_sfa_rr.h index 7c6fada7cf..34fab24d32 100644 --- a/models/iaf_cond_exp_sfa_rr.h +++ b/models/iaf_cond_exp_sfa_rr.h @@ -151,7 +151,7 @@ class iaf_cond_exp_sfa_rr : public ArchivingNode public: iaf_cond_exp_sfa_rr(); iaf_cond_exp_sfa_rr( const iaf_cond_exp_sfa_rr& ); - ~iaf_cond_exp_sfa_rr(); + ~iaf_cond_exp_sfa_rr() override; /** * Import sets of overloaded virtual functions. @@ -161,23 +161,23 @@ class iaf_cond_exp_sfa_rr : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/iaf_psc_alpha.h b/models/iaf_psc_alpha.h index ba23c33006..8d29d58d32 100644 --- a/models/iaf_psc_alpha.h +++ b/models/iaf_psc_alpha.h @@ -166,24 +166,24 @@ class iaf_psc_alpha : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< iaf_psc_alpha >; diff --git a/models/iaf_psc_alpha_canon.cpp b/models/iaf_psc_alpha_canon.cpp index 7032a8d32b..9831b44786 100644 --- a/models/iaf_psc_alpha_canon.cpp +++ b/models/iaf_psc_alpha_canon.cpp @@ -557,7 +557,6 @@ nest::iaf_psc_alpha_canon::thresh_find_( double const dt ) const default: throw BadProperty( "Invalid interpolation order in iaf_psc_alpha_canon." ); } - return 0; } // finds threshpassing via linear interpolation diff --git a/models/iaf_psc_alpha_canon.h b/models/iaf_psc_alpha_canon.h index 525c9b2294..364c95ca4c 100644 --- a/models/iaf_psc_alpha_canon.h +++ b/models/iaf_psc_alpha_canon.h @@ -186,24 +186,24 @@ class iaf_psc_alpha_canon : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } // uses off_grid events - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: /** @name Interface functions @@ -211,8 +211,8 @@ class iaf_psc_alpha_canon : public ArchivingNode * only through a Node*. */ //@{ - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** * Time Evolution Operator. @@ -231,7 +231,7 @@ class iaf_psc_alpha_canon : public ArchivingNode * While the neuron is refractory, membrane potential (y3_) is * clamped to U_reset_. */ - void update( Time const& origin, const long from, const long to ); + void update( Time const& origin, const long from, const long to ) override; //@} diff --git a/models/iaf_psc_alpha_ps.h b/models/iaf_psc_alpha_ps.h index 9747f18dfe..28c28ce667 100644 --- a/models/iaf_psc_alpha_ps.h +++ b/models/iaf_psc_alpha_ps.h @@ -173,24 +173,24 @@ class iaf_psc_alpha_ps : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } // uses off_grid events - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; /** * Based on the current state, compute the value of the membrane potential @@ -209,8 +209,8 @@ class iaf_psc_alpha_ps : public ArchivingNode * only through a Node*. */ //@{ - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; bool get_next_event_( const long T, double& ev_offset, double& ev_weight, bool& end_of_refract ); @@ -231,7 +231,7 @@ class iaf_psc_alpha_ps : public ArchivingNode * While the neuron is refractory, membrane potential (y3_) is * clamped to U_reset_. */ - void update( Time const& origin, const long from, const long to ); + void update( Time const& origin, const long from, const long to ) override; //@} diff --git a/models/iaf_psc_delta.h b/models/iaf_psc_delta.h index 50aa30fae3..8ad3f20c3b 100644 --- a/models/iaf_psc_delta.h +++ b/models/iaf_psc_delta.h @@ -156,24 +156,24 @@ class iaf_psc_delta : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< iaf_psc_delta >; diff --git a/models/iaf_psc_delta_ps.cpp b/models/iaf_psc_delta_ps.cpp index 152486f1e4..c0e85768cd 100644 --- a/models/iaf_psc_delta_ps.cpp +++ b/models/iaf_psc_delta_ps.cpp @@ -457,8 +457,6 @@ nest::iaf_psc_delta_ps::propagate_( const double dt ) const double expm1_dt = numerics::expm1( -dt / P_.tau_m_ ); const double v_inf = V_.R_ * ( S_.I_ + P_.I_e_ ); S_.U_ = -v_inf * expm1_dt + S_.U_ * expm1_dt + S_.U_; - - return; } void @@ -483,8 +481,6 @@ nest::iaf_psc_delta_ps::emit_spike_( Time const& origin, const long lag, const d SpikeEvent se; se.set_offset( S_.last_spike_offset_ ); kernel().event_delivery_manager.send( *this, se, lag ); - - return; } void @@ -505,8 +501,6 @@ nest::iaf_psc_delta_ps::emit_instant_spike_( Time const& origin, const long lag, SpikeEvent se; se.set_offset( S_.last_spike_offset_ ); kernel().event_delivery_manager.send( *this, se, lag ); - - return; } void diff --git a/models/iaf_psc_delta_ps.h b/models/iaf_psc_delta_ps.h index 3c4644fd3a..070baf7123 100644 --- a/models/iaf_psc_delta_ps.h +++ b/models/iaf_psc_delta_ps.h @@ -180,24 +180,24 @@ class iaf_psc_delta_ps : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } // uses off_grid events - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: /** @name Interface functions @@ -205,10 +205,10 @@ class iaf_psc_delta_ps : public ArchivingNode * only through a Node*. */ //@{ - void init_buffers_(); + void init_buffers_() override; - void pre_run_hook(); - void update( Time const&, const long, const long ); + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; /** * Calculate the precise spike time, emit the spike and reset the diff --git a/models/iaf_psc_exp.h b/models/iaf_psc_exp.h index 29f677ddcc..16b7548fd4 100644 --- a/models/iaf_psc_exp.h +++ b/models/iaf_psc_exp.h @@ -189,24 +189,24 @@ class iaf_psc_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( const Time&, const long, const long ); + void update( const Time&, const long, const long ) override; // intensity function double phi_() const; diff --git a/models/iaf_psc_exp_htum.h b/models/iaf_psc_exp_htum.h index da9b36973b..8d3989fd47 100644 --- a/models/iaf_psc_exp_htum.h +++ b/models/iaf_psc_exp_htum.h @@ -163,24 +163,24 @@ class iaf_psc_exp_htum : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< iaf_psc_exp_htum >; diff --git a/models/iaf_psc_exp_multisynapse.cpp b/models/iaf_psc_exp_multisynapse.cpp index 23e25a0d84..e6bcc6abc3 100644 --- a/models/iaf_psc_exp_multisynapse.cpp +++ b/models/iaf_psc_exp_multisynapse.cpp @@ -175,7 +175,7 @@ iaf_psc_exp_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* node const size_t old_n_receptors = this->n_receptors_(); if ( updateValue< std::vector< double > >( d, "tau_syn", tau_syn_ ) ) { - if ( this->n_receptors_() != old_n_receptors && has_connections_ == true ) + if ( this->n_receptors_() != old_n_receptors && has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be reduced." ); } diff --git a/models/iaf_psc_exp_multisynapse.h b/models/iaf_psc_exp_multisynapse.h index 00136edf0a..f6f118dcb6 100644 --- a/models/iaf_psc_exp_multisynapse.h +++ b/models/iaf_psc_exp_multisynapse.h @@ -102,24 +102,24 @@ class iaf_psc_exp_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class DynamicRecordablesMap< iaf_psc_exp_multisynapse >; diff --git a/models/iaf_psc_exp_ps.h b/models/iaf_psc_exp_ps.h index c8cfaaa390..8888047b6a 100644 --- a/models/iaf_psc_exp_ps.h +++ b/models/iaf_psc_exp_ps.h @@ -167,24 +167,24 @@ class iaf_psc_exp_ps : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; /** * Based on the current state, compute the value of the membrane potential @@ -203,8 +203,8 @@ class iaf_psc_exp_ps : public ArchivingNode * only through a Node*. */ //@{ - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** * Time Evolution Operator. @@ -223,7 +223,7 @@ class iaf_psc_exp_ps : public ArchivingNode * While the neuron is refractory, membrane potential (y2_) is * clamped to U_reset_. */ - void update( Time const& origin, const long from, const long to ); + void update( Time const& origin, const long from, const long to ) override; //@} // The next two classes need to be friends to access the State_ class/member diff --git a/models/iaf_psc_exp_ps_lossless.h b/models/iaf_psc_exp_ps_lossless.h index 9724af800a..f8f3b857b8 100644 --- a/models/iaf_psc_exp_ps_lossless.h +++ b/models/iaf_psc_exp_ps_lossless.h @@ -163,24 +163,24 @@ class iaf_psc_exp_ps_lossless : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, port ); - port handles_test_event( CurrentEvent&, port ); - port handles_test_event( DataLoggingRequest&, port ); + port handles_test_event( SpikeEvent&, port ) override; + port handles_test_event( CurrentEvent&, port ) override; + port handles_test_event( DataLoggingRequest&, port ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; bool - is_off_grid() const // uses off_grid events + is_off_grid() const override // uses off_grid events { return true; } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; /** * Based on the current state, compute the value of the membrane potential @@ -199,8 +199,8 @@ class iaf_psc_exp_ps_lossless : public ArchivingNode * only through a Node*. */ //@{ - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** * Time Evolution Operator. @@ -219,7 +219,7 @@ class iaf_psc_exp_ps_lossless : public ArchivingNode * While the neuron is refractory, membrane potential (y2_) is * clamped to U_reset_. */ - void update( Time const& origin, const long from, const long to ); + void update( Time const& origin, const long from, const long to ) override; //@} // The next two classes need to be friends to access the State_ class/member diff --git a/models/jonke_synapse.h b/models/jonke_synapse.h index 164b0d70b5..573e02dffc 100644 --- a/models/jonke_synapse.h +++ b/models/jonke_synapse.h @@ -260,7 +260,7 @@ class jonke_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/mat2_psc_exp.h b/models/mat2_psc_exp.h index 45af95d960..71a9b20404 100644 --- a/models/mat2_psc_exp.h +++ b/models/mat2_psc_exp.h @@ -156,23 +156,23 @@ class mat2_psc_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access private members friend class RecordablesMap< mat2_psc_exp >; diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 1a9181d31c..044465f9d2 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -181,7 +181,7 @@ ModelsModule::~ModelsModule() } const std::string -ModelsModule::name( void ) const +ModelsModule::name( ) const { return std::string( "NEST Standard Models Module" ); // Return name of the module } diff --git a/models/multimeter.cpp b/models/multimeter.cpp index 3242ac85e6..a00d73e270 100644 --- a/models/multimeter.cpp +++ b/models/multimeter.cpp @@ -206,7 +206,7 @@ multimeter::handle( DataLoggingReply& reply ) DataLoggingReply::Container const& info = reply.get_info(); // count records that have been skipped during inactivity - size_t inactive_skipped = 0; + // size_t inactive_skipped = 0; // record all data, time point by time point for ( size_t j = 0; j < info.size(); ++j ) @@ -216,11 +216,11 @@ multimeter::handle( DataLoggingReply& reply ) break; } - if ( not is_active( info[ j ].timestamp ) ) + /* if ( not is_active( info[ j ].timestamp ) ) { ++inactive_skipped; continue; - } + } */ reply.set_stamp( info[ j ].timestamp ); // const index sender = reply.get_sender_node_id(); diff --git a/models/multimeter.h b/models/multimeter.h index 42b7117f59..fec4383602 100644 --- a/models/multimeter.h +++ b/models/multimeter.h @@ -141,13 +141,13 @@ class multimeter : public RecordingDevice * sample their targets through local communication. */ bool - has_proxies() const + has_proxies() const override { return false; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -161,20 +161,20 @@ class multimeter : public RecordingDevice using Node::handles_test_event; using Node::sends_signal; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( DataLoggingReply& ); + void handle( DataLoggingReply& ) override; - SignalType sends_signal() const; + SignalType sends_signal() const override; - Type get_type() const; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + Type get_type() const override; + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; protected: - void pre_run_hook(); + void pre_run_hook() override; /** * Collect and output membrane potential information. @@ -183,7 +183,7 @@ class multimeter : public RecordingDevice * that information. The sampled nodes must provide data from * the previous time slice. */ - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; private: struct Buffers_; diff --git a/models/music_event_out_proxy.h b/models/music_event_out_proxy.h index 624dd9a765..98aec406c1 100644 --- a/models/music_event_out_proxy.h +++ b/models/music_event_out_proxy.h @@ -202,6 +202,6 @@ music_event_out_proxy::handles_test_event( SpikeEvent&, rport receptor_type ) } // namespace -#endif /* #ifndef MUSIC_EVENT_OUT_PROXY_H */ +#endif /* HAVE_MUSIC */ #endif diff --git a/models/music_rate_out_proxy.h b/models/music_rate_out_proxy.h index bad53dc70d..67eee2bd10 100644 --- a/models/music_rate_out_proxy.h +++ b/models/music_rate_out_proxy.h @@ -206,6 +206,6 @@ music_rate_out_proxy::handles_test_event( InstantaneousRateConnectionEvent&, rpo } // namespace -#endif /* #ifndef MUSIC_RATE_OUT_PROXY_H */ +#endif /* HAVE_MUSIC */ #endif diff --git a/models/parrot_neuron_ps.h b/models/parrot_neuron_ps.h index 75b810384e..a8944a8d10 100644 --- a/models/parrot_neuron_ps.h +++ b/models/parrot_neuron_ps.h @@ -91,28 +91,28 @@ class parrot_neuron_ps : public ArchivingNode using Node::handle; using Node::handles_test_event; - void handle( SpikeEvent& ); - port send_test_event( Node&, rport, synindex, bool ); - port handles_test_event( SpikeEvent&, rport ); + void handle( SpikeEvent& ) override; + port send_test_event( Node&, rport, synindex, bool ) override; + port handles_test_event( SpikeEvent&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } private: - void init_buffers_(); + void init_buffers_() override; void - pre_run_hook() + pre_run_hook() override { } // no variables - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; /** Queue for incoming events. */ struct Buffers_ diff --git a/models/pp_cond_exp_mc_urbanczik.h b/models/pp_cond_exp_mc_urbanczik.h index 89198c1e72..8a640610cc 100644 --- a/models/pp_cond_exp_mc_urbanczik.h +++ b/models/pp_cond_exp_mc_urbanczik.h @@ -92,8 +92,8 @@ class pp_cond_exp_mc_urbanczik_parameters double rate_slope; //!< Parameter of the rate function double beta; //!< Parameter of the rate function double theta; //!< Parameter of the rate function - double phi( double u ); - double h( double u ); + double phi( double u ) const; + double h( double u ) const; public: // The Urbanczik parameters need to be public within this class as they are passed to the GSL solver @@ -252,7 +252,7 @@ class pp_cond_exp_mc_urbanczik : public UrbanczikArchivingNode< pp_cond_exp_mc_u public: pp_cond_exp_mc_urbanczik(); pp_cond_exp_mc_urbanczik( const pp_cond_exp_mc_urbanczik& ); - ~pp_cond_exp_mc_urbanczik(); + ~pp_cond_exp_mc_urbanczik() override; /** * Import sets of overloaded virtual functions. @@ -262,23 +262,23 @@ class pp_cond_exp_mc_urbanczik : public UrbanczikArchivingNode< pp_cond_exp_mc_u using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // Enumerations and constants specifying structure and properties ---- @@ -533,13 +533,13 @@ class pp_cond_exp_mc_urbanczik : public UrbanczikArchivingNode< pp_cond_exp_mc_u // Inline functions of pp_cond_exp_mc_urbanczik_parameters inline double -pp_cond_exp_mc_urbanczik_parameters::phi( double u ) +pp_cond_exp_mc_urbanczik_parameters::phi( double u ) const { return phi_max / ( 1.0 + rate_slope * exp( beta * ( theta - u ) ) ); } inline double -pp_cond_exp_mc_urbanczik_parameters::h( double u ) +pp_cond_exp_mc_urbanczik_parameters::h( double u ) const { return 15.0 * beta / ( 1.0 + ( 1.0 / rate_slope ) * exp( -beta * ( theta - u ) ) ); } diff --git a/models/pp_pop_psc_delta.h b/models/pp_pop_psc_delta.h index 4e3f7ee887..0f1295eaff 100644 --- a/models/pp_pop_psc_delta.h +++ b/models/pp_pop_psc_delta.h @@ -173,24 +173,24 @@ class pp_pop_psc_delta : public Node using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< pp_pop_psc_delta >; diff --git a/models/pp_psc_delta.h b/models/pp_psc_delta.h index 06acf37a72..0484564761 100644 --- a/models/pp_psc_delta.h +++ b/models/pp_psc_delta.h @@ -207,26 +207,26 @@ class pp_psc_delta : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_state_(); - void init_buffers_(); - void pre_run_hook(); + void init_state_() override; + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< pp_psc_delta >; diff --git a/models/rate_neuron_ipn.h b/models/rate_neuron_ipn.h index 750de81700..6871ca68d0 100644 --- a/models/rate_neuron_ipn.h +++ b/models/rate_neuron_ipn.h @@ -122,29 +122,29 @@ class rate_neuron_ipn : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - void handle( InstantaneousRateConnectionEvent& ); - void handle( DelayedRateConnectionEvent& ); - void handle( DataLoggingRequest& ); + void handle( InstantaneousRateConnectionEvent& ) override; + void handle( DelayedRateConnectionEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( InstantaneousRateConnectionEvent&, rport ); - port handles_test_event( DelayedRateConnectionEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( InstantaneousRateConnectionEvent&, rport ) override; + port handles_test_event( DelayedRateConnectionEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; void - sends_secondary_event( InstantaneousRateConnectionEvent& ) + sends_secondary_event( InstantaneousRateConnectionEvent& ) override { } void - sends_secondary_event( DelayedRateConnectionEvent& ) + sends_secondary_event( DelayedRateConnectionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; TNonlinearities nonlinearities_; @@ -153,8 +153,8 @@ class rate_neuron_ipn : public ArchivingNode */ bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); - bool wfr_update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; + bool wfr_update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< rate_neuron_ipn< TNonlinearities > >; diff --git a/models/rate_neuron_opn.h b/models/rate_neuron_opn.h index c9922d63d5..591357af61 100644 --- a/models/rate_neuron_opn.h +++ b/models/rate_neuron_opn.h @@ -125,29 +125,29 @@ class rate_neuron_opn : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - void handle( InstantaneousRateConnectionEvent& ); - void handle( DelayedRateConnectionEvent& ); - void handle( DataLoggingRequest& ); + void handle( InstantaneousRateConnectionEvent& ) override; + void handle( DelayedRateConnectionEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( InstantaneousRateConnectionEvent&, rport ); - port handles_test_event( DelayedRateConnectionEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( InstantaneousRateConnectionEvent&, rport ) override; + port handles_test_event( DelayedRateConnectionEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; void - sends_secondary_event( InstantaneousRateConnectionEvent& ) + sends_secondary_event( InstantaneousRateConnectionEvent& ) override { } void - sends_secondary_event( DelayedRateConnectionEvent& ) + sends_secondary_event( DelayedRateConnectionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; TNonlinearities nonlinearities_; @@ -156,8 +156,8 @@ class rate_neuron_opn : public ArchivingNode */ bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); - bool wfr_update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; + bool wfr_update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< rate_neuron_opn< TNonlinearities > >; diff --git a/models/rate_transformer_node.h b/models/rate_transformer_node.h index 42cb66e0d5..09a1dabae2 100644 --- a/models/rate_transformer_node.h +++ b/models/rate_transformer_node.h @@ -117,37 +117,37 @@ class rate_transformer_node : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - void handle( InstantaneousRateConnectionEvent& ); - void handle( DelayedRateConnectionEvent& ); - void handle( DataLoggingRequest& ); + void handle( InstantaneousRateConnectionEvent& ) override; + void handle( DelayedRateConnectionEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( InstantaneousRateConnectionEvent&, rport ); - port handles_test_event( DelayedRateConnectionEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( InstantaneousRateConnectionEvent&, rport ) override; + port handles_test_event( DelayedRateConnectionEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; void - sends_secondary_event( InstantaneousRateConnectionEvent& ) + sends_secondary_event( InstantaneousRateConnectionEvent& ) override { } void - sends_secondary_event( DelayedRateConnectionEvent& ) + sends_secondary_event( DelayedRateConnectionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; TNonlinearities nonlinearities_; bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); - bool wfr_update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; + bool wfr_update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< rate_transformer_node< TNonlinearities > >; diff --git a/models/siegert_neuron.h b/models/siegert_neuron.h index cd324a9928..c7c2629974 100644 --- a/models/siegert_neuron.h +++ b/models/siegert_neuron.h @@ -142,7 +142,7 @@ class siegert_neuron : public ArchivingNode siegert_neuron(); siegert_neuron( const siegert_neuron& ); - ~siegert_neuron(); + ~siegert_neuron() override; /** * Import sets of overloaded virtual functions. @@ -153,31 +153,31 @@ class siegert_neuron : public ArchivingNode using Node::handles_test_event; using Node::sends_secondary_event; - void handle( DiffusionConnectionEvent& ); - void handle( DataLoggingRequest& ); + void handle( DiffusionConnectionEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( DiffusionConnectionEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( DiffusionConnectionEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; void - sends_secondary_event( DiffusionConnectionEvent& ) + sends_secondary_event( DiffusionConnectionEvent& ) override { } - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** This is the actual update function. The additional boolean parameter * determines if the function is called by update (false) or wfr_update (true) */ bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); - bool wfr_update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; + bool wfr_update( Time const&, const long, const long ) override; // siegert function double siegert( double, double ); diff --git a/models/sinusoidal_poisson_generator.cpp b/models/sinusoidal_poisson_generator.cpp index 769b2beee9..deec0ea17c 100644 --- a/models/sinusoidal_poisson_generator.cpp +++ b/models/sinusoidal_poisson_generator.cpp @@ -227,8 +227,6 @@ nest::sinusoidal_poisson_generator::pre_run_hook() V_.sin_ = std::sin( V_.h_ * P_.om_ ); // block elements V_.cos_ = std::cos( V_.h_ * P_.om_ ); - - return; } void diff --git a/models/spin_detector.h b/models/spin_detector.h index da1833e904..8d9c3c5e67 100644 --- a/models/spin_detector.h +++ b/models/spin_detector.h @@ -100,18 +100,18 @@ class spin_detector : public RecordingDevice spin_detector( const spin_detector& ); bool - has_proxies() const + has_proxies() const override { return false; } bool - local_receiver() const + local_receiver() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -125,21 +125,21 @@ class spin_detector : public RecordingDevice using Node::handles_test_event; using Node::receives_signal; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - Type get_type() const; - SignalType receives_signal() const; + Type get_type() const override; + SignalType receives_signal() const override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; - void calibrate_time( const TimeConverter& tc ); + void calibrate_time( const TimeConverter& tc ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; /** * Update detector by recording spikes. @@ -149,7 +149,7 @@ class spin_detector : public RecordingDevice * * @see RecordingDevice */ - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; index last_in_node_id_; SpikeEvent last_event_; diff --git a/models/static_synapse.h b/models/static_synapse.h index 1b024bc175..f004989ac7 100644 --- a/models/static_synapse.h +++ b/models/static_synapse.h @@ -99,42 +99,42 @@ class static_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( RateEvent&, rport ) + handles_test_event( RateEvent&, rport ) override { return invalid_port; } port - handles_test_event( DataLoggingRequest&, rport ) + handles_test_event( DataLoggingRequest&, rport ) override { return invalid_port; } port - handles_test_event( CurrentEvent&, rport ) + handles_test_event( CurrentEvent&, rport ) override { return invalid_port; } port - handles_test_event( ConductanceEvent&, rport ) + handles_test_event( ConductanceEvent&, rport ) override { return invalid_port; } port - handles_test_event( DoubleDataEvent&, rport ) + handles_test_event( DoubleDataEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSSpikeEvent&, rport ) + handles_test_event( DSSpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSCurrentEvent&, rport ) + handles_test_event( DSCurrentEvent&, rport ) override { return invalid_port; } diff --git a/models/static_synapse_hom_w.h b/models/static_synapse_hom_w.h index 5c0c87a9f6..1a5971a488 100644 --- a/models/static_synapse_hom_w.h +++ b/models/static_synapse_hom_w.h @@ -85,42 +85,42 @@ class static_synapse_hom_w : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( RateEvent&, rport ) + handles_test_event( RateEvent&, rport ) override { return invalid_port; } port - handles_test_event( DataLoggingRequest&, rport ) + handles_test_event( DataLoggingRequest&, rport ) override { return invalid_port; } port - handles_test_event( CurrentEvent&, rport ) + handles_test_event( CurrentEvent&, rport ) override { return invalid_port; } port - handles_test_event( ConductanceEvent&, rport ) + handles_test_event( ConductanceEvent&, rport ) override { return invalid_port; } port - handles_test_event( DoubleDataEvent&, rport ) + handles_test_event( DoubleDataEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSSpikeEvent&, rport ) + handles_test_event( DSSpikeEvent&, rport ) override { return invalid_port; } port - handles_test_event( DSCurrentEvent&, rport ) + handles_test_event( DSCurrentEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_dopamine_synapse.h b/models/stdp_dopamine_synapse.h index e6a582bb7d..fd616c7f92 100644 --- a/models/stdp_dopamine_synapse.h +++ b/models/stdp_dopamine_synapse.h @@ -175,7 +175,7 @@ class STDPDopaCommonProperties : public CommonSynapseProperties inline long STDPDopaCommonProperties::get_vt_node_id() const { - if ( vt_ != 0 ) + if ( vt_ != nullptr ) { return vt_->get_node_id(); } @@ -256,7 +256,7 @@ class stdp_dopamine_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } @@ -280,7 +280,7 @@ class stdp_dopamine_synapse : public Connection< targetidentifierT > void check_connection( Node& s, Node& t, rport receptor_type, const CommonPropertiesType& cp ) { - if ( cp.vt_ == 0 ) + if ( cp.vt_ == nullptr ) { throw BadProperty( "No volume transmitter has been assigned to the dopamine synapse." ); } diff --git a/models/stdp_nn_pre_centered_synapse.h b/models/stdp_nn_pre_centered_synapse.h index 6b292c870f..703697d139 100644 --- a/models/stdp_nn_pre_centered_synapse.h +++ b/models/stdp_nn_pre_centered_synapse.h @@ -178,7 +178,7 @@ class stdp_nn_pre_centered_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_nn_restr_synapse.h b/models/stdp_nn_restr_synapse.h index 0f86b8ffdc..ffbbfea72d 100644 --- a/models/stdp_nn_restr_synapse.h +++ b/models/stdp_nn_restr_synapse.h @@ -173,7 +173,7 @@ class stdp_nn_restr_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } @@ -341,7 +341,7 @@ stdp_nn_restr_synapse< targetidentifierT >::set_status( const DictionaryDatum& d updateValue< double >( d, names::Wmax, Wmax_ ); // check if weight_ and Wmax_ have the same sign - if ( not( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) == ( ( Wmax_ >= 0 ) - ( Wmax_ < 0 ) ) ) ) + if ( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) != ( ( Wmax_ >= 0 ) - ( Wmax_ < 0 ) ) ) { throw BadProperty( "Weight and Wmax must have same sign." ); } diff --git a/models/stdp_nn_symm_synapse.h b/models/stdp_nn_symm_synapse.h index a9d40796b2..b157bc4259 100644 --- a/models/stdp_nn_symm_synapse.h +++ b/models/stdp_nn_symm_synapse.h @@ -331,7 +331,7 @@ stdp_nn_symm_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, updateValue< double >( d, names::Wmax, Wmax_ ); // check if weight_ and Wmax_ have the same sign - if ( not( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) == ( ( Wmax_ >= 0 ) - ( Wmax_ < 0 ) ) ) ) + if ( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) != ( ( Wmax_ >= 0 ) - ( Wmax_ < 0 ) ) ) { throw BadProperty( "Weight and Wmax must have same sign." ); } diff --git a/models/stdp_pl_synapse_hom.h b/models/stdp_pl_synapse_hom.h index 601c9b10c3..fff70ca187 100644 --- a/models/stdp_pl_synapse_hom.h +++ b/models/stdp_pl_synapse_hom.h @@ -177,7 +177,7 @@ class stdp_pl_synapse_hom : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_synapse.h b/models/stdp_synapse.h index 969dc02678..53e4ff8af6 100644 --- a/models/stdp_synapse.h +++ b/models/stdp_synapse.h @@ -165,7 +165,7 @@ class stdp_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_synapse_facetshw_hom.h b/models/stdp_synapse_facetshw_hom.h index e611eb9cf3..e312be80a8 100644 --- a/models/stdp_synapse_facetshw_hom.h +++ b/models/stdp_synapse_facetshw_hom.h @@ -281,7 +281,7 @@ class stdp_facetshw_synapse_hom : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } @@ -412,7 +412,7 @@ stdp_facetshw_synapse_hom< targetidentifierT >::send( Event& e, const_cast< STDPFACETSHWHomCommonProperties< targetidentifierT >& >( cp ); // init the readout time - if ( init_flag_ == false ) + if ( !init_flag_ ) { synapse_id_ = cp.no_synapses_; ++cp_nonconst.no_synapses_; diff --git a/models/stdp_synapse_hom.h b/models/stdp_synapse_hom.h index 3658423286..8c880f7206 100644 --- a/models/stdp_synapse_hom.h +++ b/models/stdp_synapse_hom.h @@ -210,7 +210,7 @@ class stdp_synapse_hom : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_triplet_synapse.h b/models/stdp_triplet_synapse.h index 35fb352cf2..49940e7f96 100644 --- a/models/stdp_triplet_synapse.h +++ b/models/stdp_triplet_synapse.h @@ -358,7 +358,7 @@ stdp_triplet_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, throw BadProperty( "State Kplus must be positive." ); } - if ( not( Kplus_triplet_ >= 0 ) ) + if ( Kplus_triplet_ < 0 ) { throw BadProperty( "State Kplus_triplet must be positive." ); } diff --git a/models/tsodyks_synapse_hom.h b/models/tsodyks_synapse_hom.h index 1773b06033..7436827f54 100644 --- a/models/tsodyks_synapse_hom.h +++ b/models/tsodyks_synapse_hom.h @@ -224,7 +224,7 @@ class tsodyks_synapse_hom : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/urbanczik_synapse.h b/models/urbanczik_synapse.h index 26a0b03396..dc833dce69 100644 --- a/models/urbanczik_synapse.h +++ b/models/urbanczik_synapse.h @@ -159,7 +159,7 @@ class urbanczik_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } @@ -312,7 +312,7 @@ urbanczik_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Co init_weight_ = weight_; // check if weight_ and Wmin_ has the same sign - if ( not( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) == ( ( Wmin_ >= 0 ) - ( Wmin_ < 0 ) ) ) ) + if ( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) != ( ( Wmin_ >= 0 ) - ( Wmin_ < 0 ) ) ) { throw BadProperty( "Weight and Wmin must have same sign." ); } diff --git a/models/vogels_sprekeler_synapse.h b/models/vogels_sprekeler_synapse.h index 872e5fc2aa..03c02430f7 100644 --- a/models/vogels_sprekeler_synapse.h +++ b/models/vogels_sprekeler_synapse.h @@ -142,7 +142,7 @@ class vogels_sprekeler_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/volume_transmitter.h b/models/volume_transmitter.h index abac11b113..f033fb3258 100644 --- a/models/volume_transmitter.h +++ b/models/volume_transmitter.h @@ -111,19 +111,19 @@ class volume_transmitter : public Node volume_transmitter( const volume_transmitter& ); bool - has_proxies() const + has_proxies() const override { return false; } bool - local_receiver() const + local_receiver() const override { return false; } Name - get_element_type() const + get_element_type() const override { return names::other; } @@ -136,28 +136,28 @@ class volume_transmitter : public Node using Node::handle; using Node::handles_test_event; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - void get_status( DictionaryDatum& d ) const; - void set_status( const DictionaryDatum& d ); + void get_status( DictionaryDatum& d ) const override; + void set_status( const DictionaryDatum& d ) override; /** * Since volume transmitters are duplicated on each thread, and are * hence treated just as devices during node creation, we need to * define the corresponding setter and getter for local_device_id. **/ - void set_local_device_id( const index ldid ); - index get_local_device_id() const; + void set_local_device_id( const index ldid ) override; + index get_local_device_id() const override; const std::vector< spikecounter >& deliver_spikes(); private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( const Time&, const long, const long ); + void update( const Time&, const long, const long ) override; // -------------------------------------------- diff --git a/nestkernel/archiving_node.h b/nestkernel/archiving_node.h index 5da56af8d7..6cc629364c 100644 --- a/nestkernel/archiving_node.h +++ b/nestkernel/archiving_node.h @@ -67,7 +67,7 @@ class ArchivingNode : public StructuralPlasticityNode * requested at the exact same time that the neuron emits a spike, the trace * value as it was just before the spike is returned. */ - double get_K_value( double t ); + double get_K_value( double t ) override; /** * \fn void get_K_values( double t, @@ -82,7 +82,7 @@ class ArchivingNode : public StructuralPlasticityNode * values at t (in ms) to the provided locations. * @throws UnexpectedEvent */ - void get_K_values( double t, double& Kminus, double& nearest_neighbor_Kminus, double& Kminus_triplet ); + void get_K_values( double t, double& Kminus, double& nearest_neighbor_Kminus, double& Kminus_triplet ) override; /** * \fn void get_K_values( double t, @@ -103,7 +103,7 @@ class ArchivingNode : public StructuralPlasticityNode * \fn double get_K_triplet_value(std::deque::iterator &iter) * return the triplet Kminus value for the associated iterator. */ - double get_K_triplet_value( const std::deque< histentry >::iterator& iter ); + // double get_K_triplet_value( const std::deque< histentry >::iterator& iter ); /** * \fn void get_history(long t1, long t2, @@ -115,7 +115,7 @@ class ArchivingNode : public StructuralPlasticityNode void get_history( double t1, double t2, std::deque< histentry >::iterator* start, - std::deque< histentry >::iterator* finish ); + std::deque< histentry >::iterator* finish ) override; /** * Register a new incoming STDP connection. @@ -123,10 +123,10 @@ class ArchivingNode : public StructuralPlasticityNode * t_first_read: The newly registered synapse will read the history entries * with t > t_first_read. */ - void register_stdp_connection( double t_first_read, double delay ); + void register_stdp_connection( double t_first_read, double delay ) override; - void get_status( DictionaryDatum& d ) const; - void set_status( const DictionaryDatum& d ); + void get_status( DictionaryDatum& d ) const override; + void set_status( const DictionaryDatum& d ) override; protected: /** diff --git a/nestkernel/clopath_archiving_node.h b/nestkernel/clopath_archiving_node.h index 98f5adccc3..26904ace29 100644 --- a/nestkernel/clopath_archiving_node.h +++ b/nestkernel/clopath_archiving_node.h @@ -64,7 +64,7 @@ class ClopathArchivingNode : public ArchivingNode * \fn double get_LTD_value(long t) * Returns value in LTD history at time t */ - double get_LTD_value( double t ); + double get_LTD_value( double t ) override; /** * \fn void get_LTP_history(long t1, long t2, @@ -76,7 +76,7 @@ class ClopathArchivingNode : public ArchivingNode void get_LTP_history( double t1, double t2, std::deque< histentry_extended >::iterator* start, - std::deque< histentry_extended >::iterator* finish ); + std::deque< histentry_extended >::iterator* finish ) override; /** * \fn double get_theta_plus() @@ -117,8 +117,8 @@ class ClopathArchivingNode : public ArchivingNode void write_clopath_history( Time const& t_sp, double u, double u_bar_plus, double u_bar_minus, double u_bar_bar ); void init_clopath_buffers(); - void get_status( DictionaryDatum& d ) const; - void set_status( const DictionaryDatum& d ); + void get_status( DictionaryDatum& d ) const override; + void set_status( const DictionaryDatum& d ) override; private: std::vector< histentry_extended > ltd_history_; diff --git a/nestkernel/common_synapse_properties.cpp b/nestkernel/common_synapse_properties.cpp index 69502b1d55..1a06fb46fc 100644 --- a/nestkernel/common_synapse_properties.cpp +++ b/nestkernel/common_synapse_properties.cpp @@ -79,7 +79,7 @@ CommonSynapseProperties::set_status( const DictionaryDatum& d, ConnectorModel& ) Node* CommonSynapseProperties::get_node() { - return 0; + return nullptr; } void diff --git a/nestkernel/conn_builder.h b/nestkernel/conn_builder.h index 7229b4a625..dc1dbb4d4a 100644 --- a/nestkernel/conn_builder.h +++ b/nestkernel/conn_builder.h @@ -266,22 +266,22 @@ class OneToOneBuilder : public ConnBuilder const std::vector< DictionaryDatum >& syn_specs ); bool - supports_symmetric() const + supports_symmetric() const override { return true; } bool - requires_proxies() const + requires_proxies() const override { return false; } protected: - void connect_(); - void sp_connect_(); - void disconnect_(); - void sp_disconnect_(); + void connect_() override; + void sp_connect_() override; + void disconnect_() override; + void sp_disconnect_() override; }; class AllToAllBuilder : public ConnBuilder @@ -296,22 +296,22 @@ class AllToAllBuilder : public ConnBuilder } bool - is_symmetric() const + is_symmetric() const override { return sources_ == targets_ and all_parameters_scalar_(); } bool - requires_proxies() const + requires_proxies() const override { return false; } protected: - void connect_(); - void sp_connect_(); - void disconnect_(); - void sp_disconnect_(); + void connect_() override; + void sp_connect_() override; + void disconnect_() override; + void sp_disconnect_() override; private: void inner_connect_( const int, RngPtr, Node*, index, bool ); @@ -327,7 +327,7 @@ class FixedInDegreeBuilder : public ConnBuilder const std::vector< DictionaryDatum >& ); protected: - void connect_(); + void connect_() override; private: void inner_connect_( const int, RngPtr, Node*, index, bool, long ); @@ -343,7 +343,7 @@ class FixedOutDegreeBuilder : public ConnBuilder const std::vector< DictionaryDatum >& ); protected: - void connect_(); + void connect_() override; private: ParameterDatum outdegree_; @@ -358,7 +358,7 @@ class FixedTotalNumberBuilder : public ConnBuilder const std::vector< DictionaryDatum >& ); protected: - void connect_(); + void connect_() override; private: long N_; @@ -373,7 +373,7 @@ class BernoulliBuilder : public ConnBuilder const std::vector< DictionaryDatum >& ); protected: - void connect_(); + void connect_() override; private: void inner_connect_( const int, RngPtr, Node*, index ); @@ -389,13 +389,13 @@ class SymmetricBernoulliBuilder : public ConnBuilder const std::vector< DictionaryDatum >& ); bool - supports_symmetric() const + supports_symmetric() const override { return true; } protected: - void connect_(); + void connect_() override; private: double p_; //!< connection probability @@ -434,7 +434,7 @@ class SPBuilder : public ConnBuilder protected: using ConnBuilder::connect_; - void connect_(); + void connect_() override; void connect_( NodeCollectionPTR sources, NodeCollectionPTR targets ); /** diff --git a/nestkernel/conn_builder_factory.h b/nestkernel/conn_builder_factory.h index 93295d7b8b..1cd041ca96 100644 --- a/nestkernel/conn_builder_factory.h +++ b/nestkernel/conn_builder_factory.h @@ -69,7 +69,7 @@ class ConnBuilderFactory : public GenericConnBuilderFactory create( NodeCollectionPTR sources, NodeCollectionPTR targets, const DictionaryDatum& conn_spec, - const std::vector< DictionaryDatum >& syn_specs ) const + const std::vector< DictionaryDatum >& syn_specs ) const override { return new ConnBuilderType( sources, targets, conn_spec, syn_specs ); } diff --git a/nestkernel/conn_parameter.h b/nestkernel/conn_parameter.h index d1448d9f06..b260fbb832 100644 --- a/nestkernel/conn_parameter.h +++ b/nestkernel/conn_parameter.h @@ -134,30 +134,30 @@ class ScalarDoubleParameter : public ConnParameter } double - value_double( thread, RngPtr, index, Node* ) const + value_double( thread, RngPtr, index, Node* ) const override { return value_; } long - value_int( thread, RngPtr, index, Node* ) const + value_int( thread, RngPtr, index, Node* ) const override { throw KernelException( "ConnParameter calls value function with false return type." ); } inline bool - is_array() const + is_array() const override { return false; } void - reset() const + reset() const override { } bool - is_scalar() const + is_scalar() const override { return true; } @@ -180,36 +180,36 @@ class ScalarIntegerParameter : public ConnParameter } double - value_double( thread, RngPtr, index, Node* ) const + value_double( thread, RngPtr, index, Node* ) const override { return static_cast< double >( value_ ); } long - value_int( thread, RngPtr, index, Node* ) const + value_int( thread, RngPtr, index, Node* ) const override { return value_; } inline bool - is_array() const + is_array() const override { return false; } void - reset() const + reset() const override { } bool - is_scalar() const + is_scalar() const override { return true; } bool - provides_long() const + provides_long() const override { return true; } @@ -244,7 +244,7 @@ class ArrayDoubleParameter : public ConnParameter } void - skip( thread tid, size_t n_skip ) const + skip( thread tid, size_t n_skip ) const override { if ( next_[ tid ] < values_->end() ) { @@ -257,13 +257,13 @@ class ArrayDoubleParameter : public ConnParameter } size_t - number_of_values() const + number_of_values() const override { return values_->size(); } double - value_double( thread tid, RngPtr, index, Node* ) const + value_double( thread tid, RngPtr, index, Node* ) const override { if ( next_[ tid ] != values_->end() ) { @@ -276,19 +276,19 @@ class ArrayDoubleParameter : public ConnParameter } long - value_int( thread, RngPtr, index, Node* ) const + value_int( thread, RngPtr, index, Node* ) const override { throw KernelException( "ConnParameter calls value function with false return type." ); } inline bool - is_array() const + is_array() const override { return true; } void - reset() const + reset() const override { for ( std::vector< std::vector< double >::const_iterator >::iterator it = next_.begin(); it != next_.end(); ++it ) { @@ -326,7 +326,7 @@ class ArrayIntegerParameter : public ConnParameter } void - skip( thread tid, size_t n_skip ) const + skip( thread tid, size_t n_skip ) const override { if ( next_[ tid ] < values_->end() ) { @@ -339,13 +339,13 @@ class ArrayIntegerParameter : public ConnParameter } size_t - number_of_values() const + number_of_values() const override { return values_->size(); } long - value_int( thread tid, RngPtr, index, Node* ) const + value_int( thread tid, RngPtr, index, Node* ) const override { if ( next_[ tid ] != values_->end() ) { @@ -358,7 +358,7 @@ class ArrayIntegerParameter : public ConnParameter } double - value_double( thread tid, RngPtr, index, Node* ) const + value_double( thread tid, RngPtr, index, Node* ) const override { if ( next_[ tid ] != values_->end() ) { @@ -371,19 +371,19 @@ class ArrayIntegerParameter : public ConnParameter } inline bool - is_array() const + is_array() const override { return true; } bool - provides_long() const + provides_long() const override { return true; } void - reset() const + reset() const override { for ( std::vector< std::vector< long >::const_iterator >::iterator it = next_.begin(); it != next_.end(); ++it ) { @@ -401,22 +401,22 @@ class ParameterConnParameterWrapper : public ConnParameter public: ParameterConnParameterWrapper( const ParameterDatum&, const size_t ); - double value_double( thread target_thread, RngPtr rng, index snode_id, Node* target ) const; + double value_double( thread target_thread, RngPtr rng, index snode_id, Node* target ) const override; long - value_int( thread target_thread, RngPtr rng, index snode_id, Node* target ) const + value_int( thread target_thread, RngPtr rng, index snode_id, Node* target ) const override { return value_double( target_thread, rng, snode_id, target ); } inline bool - is_array() const + is_array() const override { return false; } bool - provides_long() const + provides_long() const override { return parameter_->returns_int_only(); } diff --git a/nestkernel/connection_manager.h b/nestkernel/connection_manager.h index 5808b5f8ca..1f2501c298 100644 --- a/nestkernel/connection_manager.h +++ b/nestkernel/connection_manager.h @@ -78,11 +78,11 @@ class ConnectionManager : public ManagerInterface ConnectionManager(); virtual ~ConnectionManager(); - virtual void initialize() override; - virtual void finalize() override; - virtual void change_number_of_threads() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void change_number_of_threads() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; bool valid_connection_rule( std::string ); diff --git a/nestkernel/connection_manager_impl.h b/nestkernel/connection_manager_impl.h index 4ad472b457..ca5534d61f 100644 --- a/nestkernel/connection_manager_impl.h +++ b/nestkernel/connection_manager_impl.h @@ -44,7 +44,7 @@ ConnectionManager::register_conn_builder( const std::string& name ) { assert( not connruledict_->known( name ) ); GenericConnBuilderFactory* cb = new ConnBuilderFactory< ConnBuilder >(); - assert( cb != 0 ); + assert( cb != nullptr ); const int id = connbuilder_factories_.size(); connbuilder_factories_.push_back( cb ); connruledict_->insert( name, id ); diff --git a/nestkernel/connector_base.h b/nestkernel/connector_base.h index 7309feefde..a76aa85d2c 100644 --- a/nestkernel/connector_base.h +++ b/nestkernel/connector_base.h @@ -225,25 +225,25 @@ class Connector : public ConnectorBase { } - ~Connector() + ~Connector() override { C_.clear(); } synindex - get_syn_id() const + get_syn_id() const override { return syn_id_; } size_t - size() const + size() const override { return C_.size(); } void - get_synapse_status( const thread tid, const index lcid, DictionaryDatum& dict ) const + get_synapse_status( const thread tid, const index lcid, DictionaryDatum& dict ) const override { assert( lcid < C_.size() ); @@ -255,7 +255,7 @@ class Connector : public ConnectorBase } void - set_synapse_status( const index lcid, const DictionaryDatum& dict, ConnectorModel& cm ) + set_synapse_status( const index lcid, const DictionaryDatum& dict, ConnectorModel& cm ) override { assert( lcid < C_.size() ); @@ -274,7 +274,7 @@ class Connector : public ConnectorBase const thread tid, const index lcid, const long synapse_label, - std::deque< ConnectionID >& conns ) const + std::deque< ConnectionID >& conns ) const override { if ( not C_[ lcid ].is_disabled() ) { @@ -296,7 +296,7 @@ class Connector : public ConnectorBase const thread tid, const index lcid, const long synapse_label, - std::deque< ConnectionID >& conns ) const + std::deque< ConnectionID >& conns ) const override { if ( not C_[ lcid ].is_disabled() ) { @@ -318,7 +318,7 @@ class Connector : public ConnectorBase const index target_node_id, const thread tid, const long synapse_label, - std::deque< ConnectionID >& conns ) const + std::deque< ConnectionID >& conns ) const override { for ( size_t lcid = 0; lcid < C_.size(); ++lcid ) { @@ -327,7 +327,7 @@ class Connector : public ConnectorBase } void - get_source_lcids( const thread tid, const index target_node_id, std::vector< index >& source_lcids ) const + get_source_lcids( const thread tid, const index target_node_id, std::vector< index >& source_lcids ) const override { for ( index lcid = 0; lcid < C_.size(); ++lcid ) { @@ -343,7 +343,7 @@ class Connector : public ConnectorBase get_target_node_ids( const thread tid, const index start_lcid, const std::string& post_synaptic_element, - std::vector< index >& target_node_ids ) const + std::vector< index >& target_node_ids ) const override { index lcid = start_lcid; while ( true ) @@ -364,13 +364,13 @@ class Connector : public ConnectorBase } index - get_target_node_id( const thread tid, const unsigned int lcid ) const + get_target_node_id( const thread tid, const unsigned int lcid ) const override { return C_[ lcid ].get_target( tid )->get_node_id(); } void - send_to_all( const thread tid, const std::vector< ConnectorModel* >& cm, Event& e ) + send_to_all( const thread tid, const std::vector< ConnectorModel* >& cm, Event& e ) override { for ( size_t lcid = 0; lcid < C_.size(); ++lcid ) { @@ -382,7 +382,7 @@ class Connector : public ConnectorBase } index - send( const thread tid, const index lcid, const std::vector< ConnectorModel* >& cm, Event& e ) + send( const thread tid, const index lcid, const std::vector< ConnectorModel* >& cm, Event& e ) override { typename ConnectionT::CommonPropertiesType const& cp = static_cast< GenericConnectorModel< ConnectionT >* >( cm[ syn_id_ ] )->get_common_properties(); @@ -412,14 +412,14 @@ class Connector : public ConnectorBase } // Implemented in connector_base_impl.h - void send_weight_event( const thread tid, const unsigned int lcid, Event& e, const CommonSynapseProperties& cp ); + void send_weight_event( const thread tid, const unsigned int lcid, Event& e, const CommonSynapseProperties& cp ) override; void trigger_update_weight( const long vt_node_id, const thread tid, const std::vector< spikecounter >& dopa_spikes, const double t_trig, - const std::vector< ConnectorModel* >& cm ) + const std::vector< ConnectorModel* >& cm ) override { for ( size_t i = 0; i < C_.size(); ++i ) { @@ -437,19 +437,19 @@ class Connector : public ConnectorBase } void - sort_connections( BlockVector< Source >& sources ) + sort_connections( BlockVector< Source >& sources ) override { nest::sort( sources, C_ ); } void - set_source_has_more_targets( const index lcid, const bool has_more_targets ) + set_source_has_more_targets( const index lcid, const bool has_more_targets ) override { C_[ lcid ].set_source_has_more_targets( has_more_targets ); } index - find_first_target( const thread tid, const index start_lcid, const index target_node_id ) const + find_first_target( const thread tid, const index start_lcid, const index target_node_id ) const override { index lcid = start_lcid; while ( true ) @@ -469,7 +469,7 @@ class Connector : public ConnectorBase } index - find_matching_target( const thread tid, const std::vector< index >& matching_lcids, const index target_node_id ) const + find_matching_target( const thread tid, const std::vector< index >& matching_lcids, const index target_node_id ) const override { for ( size_t i = 0; i < matching_lcids.size(); ++i ) { @@ -483,14 +483,14 @@ class Connector : public ConnectorBase } void - disable_connection( const index lcid ) + disable_connection( const index lcid ) override { assert( not C_[ lcid ].is_disabled() ); C_[ lcid ].disable(); } void - remove_disabled_connections( const index first_disabled_index ) + remove_disabled_connections( const index first_disabled_index ) override { assert( C_[ first_disabled_index ].is_disabled() ); C_.erase( C_.begin() + first_disabled_index, C_.end() ); diff --git a/nestkernel/connector_model.h b/nestkernel/connector_model.h index 83169c87e4..a711c9d702 100644 --- a/nestkernel/connector_model.h +++ b/nestkernel/connector_model.h @@ -213,31 +213,31 @@ class GenericConnectorModel : public ConnectorModel const synindex syn_id, const DictionaryDatum& d, const double delay, - const double weight ); + const double weight ) override; - ConnectorModel* clone( std::string ) const; + ConnectorModel* clone( std::string ) const override; - void calibrate( const TimeConverter& tc ); + void calibrate( const TimeConverter& tc ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; void - check_synapse_params( const DictionaryDatum& syn_spec ) const + check_synapse_params( const DictionaryDatum& syn_spec ) const override { default_connection_.check_synapse_params( syn_spec ); } typename ConnectionT::CommonPropertiesType const& - get_common_properties() const + get_common_properties() const override { return cp_; } - void set_syn_id( synindex syn_id ); + void set_syn_id( synindex syn_id ) override; - virtual typename ConnectionT::EventType* - get_event() const + typename ConnectionT::EventType* + get_event() const override { assert( false ); return 0; @@ -249,13 +249,13 @@ class GenericConnectorModel : public ConnectorModel return default_connection_; } - virtual SecondaryEvent* - create_event() const + SecondaryEvent* + create_event() const override { // Must not be called for a ConnectorModel belonging to a primary // connection. Only required for secondary connection types. assert( false ); - return 0; // make the compiler happy + return nullptr; // make the compiler happy } private: diff --git a/nestkernel/connector_model_impl.h b/nestkernel/connector_model_impl.h index 7ccf0bfaf3..7f5ef98f26 100644 --- a/nestkernel/connector_model_impl.h +++ b/nestkernel/connector_model_impl.h @@ -264,7 +264,7 @@ GenericConnectorModel< ConnectionT >::add_connection_( Node& src, { assert( syn_id != invalid_synindex ); - if ( thread_local_connectors[ syn_id ] == NULL ) + if ( thread_local_connectors[ syn_id ] == nullptr ) { // No homogeneous Connector with this syn_id exists, we need to create a new // homogeneous Connector. @@ -275,7 +275,7 @@ GenericConnectorModel< ConnectionT >::add_connection_( Node& src, // The following line will throw an exception, if it does not work. connection.check_connection( src, tgt, receptor_type, get_common_properties() ); - assert( connector != 0 ); + assert( connector != nullptr ); Connector< ConnectionT >* vc = static_cast< Connector< ConnectionT >* >( connector ); vc->push_back( connection ); diff --git a/nestkernel/dynamicloader.cpp b/nestkernel/dynamicloader.cpp index 009f9e2d3a..2bae8c6186 100644 --- a/nestkernel/dynamicloader.cpp +++ b/nestkernel/dynamicloader.cpp @@ -103,10 +103,10 @@ DynamicLoaderModule::~DynamicLoaderModule() // unload all loaded modules for ( vecDynModules::iterator it = dyn_modules.begin(); it != dyn_modules.end(); ++it ) { - if ( it->handle != NULL ) + if ( it->handle != nullptr ) { lt_dlclose( it->handle ); - it->handle = NULL; + it->handle = nullptr; } } @@ -116,13 +116,13 @@ DynamicLoaderModule::~DynamicLoaderModule() // The following concerns the new module: ----------------------- const std::string -DynamicLoaderModule::name( void ) const +DynamicLoaderModule::name( ) const { return std::string( "NEST-Dynamic Loader" ); // Return name of the module } const std::string -DynamicLoaderModule::commandstring( void ) const +DynamicLoaderModule::commandstring( ) const { return std::string( "" ); // Run associated SLI startup script } @@ -284,7 +284,7 @@ DynamicLoaderModule::init( SLIInterpreter* i ) int DynamicLoaderModule::registerLinkedModule( SLIModule* pModule ) { - assert( pModule != 0 ); + assert( pModule != nullptr ); getLinkedModules().push_back( pModule ); return getLinkedModules().size(); } diff --git a/nestkernel/dynamicloader.h b/nestkernel/dynamicloader.h index 225a8ad4dd..a4613aae18 100644 --- a/nestkernel/dynamicloader.h +++ b/nestkernel/dynamicloader.h @@ -58,12 +58,12 @@ class DynamicLoaderModule : public SLIModule { public: DynamicLoaderModule( SLIInterpreter& interpreter ); - ~DynamicLoaderModule(); + ~DynamicLoaderModule() override; - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; - const std::string commandstring( void ) const; - const std::string name( void ) const; + const std::string commandstring( ) const override; + const std::string name( ) const override; /** @@ -85,7 +85,7 @@ class DynamicLoaderModule : public SLIModule LoadModuleFunction( vecDynModules& dyn_modules ); private: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; private: vecDynModules& dyn_modules_; diff --git a/nestkernel/event.cpp b/nestkernel/event.cpp index 109c094833..36c385d669 100644 --- a/nestkernel/event.cpp +++ b/nestkernel/event.cpp @@ -40,8 +40,8 @@ Event::Event() // node ID 0 is network, can never send an event, so // this is safe , sender_spike_data_() - , sender_( NULL ) - , receiver_( NULL ) + , sender_( nullptr ) + , receiver_( nullptr ) , p_( -1 ) , rp_( 0 ) , d_( 1 ) diff --git a/nestkernel/event.h b/nestkernel/event.h index b00ff3f290..b4fe5b7727 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -374,8 +374,8 @@ class SpikeEvent : public Event { public: SpikeEvent(); - void operator()(); - SpikeEvent* clone() const; + void operator()() override; + SpikeEvent* clone() const override; void set_multiplicity( int ); int get_multiplicity() const; @@ -415,8 +415,8 @@ class WeightRecorderEvent : public Event { public: WeightRecorderEvent(); - WeightRecorderEvent* clone() const; - void operator()(); + WeightRecorderEvent* clone() const override; + void operator()() override; /** * Return node ID of receiving Node. @@ -451,7 +451,7 @@ WeightRecorderEvent::set_receiver_node_id( index node_id ) } inline index -WeightRecorderEvent::get_receiver_node_id( void ) const +WeightRecorderEvent::get_receiver_node_id( ) const { return receiver_node_id_; } @@ -476,7 +476,7 @@ WeightRecorderEvent::get_receiver_node_id( void ) const class DSSpikeEvent : public SpikeEvent { public: - void operator()(); + void operator()() override; }; /** @@ -491,8 +491,8 @@ class RateEvent : public Event double r_; public: - void operator()(); - RateEvent* clone() const; + void operator()() override; + RateEvent* clone() const override; void set_rate( double ); double get_rate() const; @@ -525,8 +525,8 @@ class CurrentEvent : public Event double c_; public: - void operator()(); - CurrentEvent* clone() const; + void operator()() override; + CurrentEvent* clone() const override; void set_current( double ); double get_current() const; @@ -569,7 +569,7 @@ CurrentEvent::get_current() const class DSCurrentEvent : public CurrentEvent { public: - void operator()(); + void operator()() override; }; /** @@ -599,9 +599,9 @@ class DataLoggingRequest : public Event * and vector of recordables. */ DataLoggingRequest( const Time&, const Time&, const std::vector< Name >& ); - DataLoggingRequest* clone() const; + DataLoggingRequest* clone() const override; - void operator()(); + void operator()() override; /** Access to stored time interval.*/ const Time& get_recording_interval() const; @@ -630,7 +630,7 @@ inline DataLoggingRequest::DataLoggingRequest() : Event() , recording_interval_( Time::neg_inf() ) , recording_offset_( Time::ms( 0. ) ) - , record_from_( 0 ) + , record_from_( nullptr ) { } @@ -680,7 +680,7 @@ DataLoggingRequest::record_from() const { // During simulation, events are created without recordables // information. On these, record_from() must not be called. - assert( record_from_ != 0 ); + assert( record_from_ != nullptr ); return *record_from_; } @@ -720,7 +720,7 @@ class DataLoggingReply : public Event //! Construct with reference to data and time stamps to transmit DataLoggingReply( const Container& ); - void operator()(); + void operator()() override; //! Access referenced data const Container& @@ -735,10 +735,10 @@ class DataLoggingReply : public Event //! Prohibit cloning DataLoggingReply* - clone() const + clone() const override { assert( false ); - return 0; + return nullptr; } //! data to be transmitted, with time stamps @@ -761,8 +761,8 @@ class ConductanceEvent : public Event double g_; public: - void operator()(); - ConductanceEvent* clone() const; + void operator()() override; + ConductanceEvent* clone() const override; void set_conductance( double ); double get_conductance() const; @@ -829,8 +829,8 @@ DataEvent< D >::get_pointer() const class DoubleDataEvent : public DataEvent< double > { public: - void operator()(); - DoubleDataEvent* clone() const; + void operator()() override; + DoubleDataEvent* clone() const override; }; inline DoubleDataEvent* @@ -1020,7 +1020,7 @@ class DataSecondaryEvent : public SecondaryEvent * it is called from a pointer on SecondaryEvent. */ void - add_syn_id( const synindex synid ) + add_syn_id( const synindex synid ) override { assert( not supports_syn_id( synid ) ); VPManager::assert_single_threaded(); @@ -1028,7 +1028,7 @@ class DataSecondaryEvent : public SecondaryEvent } const std::vector< synindex >& - get_supported_syn_ids() const + get_supported_syn_ids() const override { return supported_syn_ids_; } @@ -1041,7 +1041,7 @@ class DataSecondaryEvent : public SecondaryEvent * models. */ void - reset_supported_syn_ids() + reset_supported_syn_ids() override { supported_syn_ids_.clear(); for ( size_t i = 0; i < pristine_supported_syn_ids_.size(); ++i ) @@ -1058,7 +1058,7 @@ class DataSecondaryEvent : public SecondaryEvent } bool - supports_syn_id( const synindex synid ) const + supports_syn_id( const synindex synid ) const override { return ( std::find( supported_syn_ids_.begin(), supported_syn_ids_.end(), synid ) != supported_syn_ids_.end() ); } @@ -1076,7 +1076,7 @@ class DataSecondaryEvent : public SecondaryEvent * DataSecondaryEvent from the buffer in EventDeliveryManager::deliver_events */ std::vector< unsigned int >::iterator& - operator<<( std::vector< unsigned int >::iterator& pos ) + operator<<( std::vector< unsigned int >::iterator& pos ) override { // The synid can be skipped here as it is stored in a static vector @@ -1098,7 +1098,7 @@ class DataSecondaryEvent : public SecondaryEvent * first element in supported_syn_ids_. */ std::vector< unsigned int >::iterator& - operator>>( std::vector< unsigned int >::iterator& pos ) + operator>>( std::vector< unsigned int >::iterator& pos ) override { for ( typename std::vector< DataType >::iterator it = coeffarray_begin_.as_d; it != coeffarray_end_.as_d; ++it ) { @@ -1110,7 +1110,7 @@ class DataSecondaryEvent : public SecondaryEvent } size_t - size() + size() override { size_t s = number_of_uints_covered< synindex >(); s += number_of_uints_covered< index >(); @@ -1146,8 +1146,8 @@ class GapJunctionEvent : public DataSecondaryEvent< double, GapJunctionEvent > { } - void operator()(); - GapJunctionEvent* clone() const; + void operator()() override; + GapJunctionEvent* clone() const override; }; /** @@ -1162,8 +1162,8 @@ class InstantaneousRateConnectionEvent : public DataSecondaryEvent< double, Inst { } - void operator()(); - InstantaneousRateConnectionEvent* clone() const; + void operator()() override; + InstantaneousRateConnectionEvent* clone() const override; }; /** @@ -1178,8 +1178,8 @@ class DelayedRateConnectionEvent : public DataSecondaryEvent< double, DelayedRat { } - void operator()(); - DelayedRateConnectionEvent* clone() const; + void operator()() override; + DelayedRateConnectionEvent* clone() const override; }; /** @@ -1199,17 +1199,17 @@ class DiffusionConnectionEvent : public DataSecondaryEvent< double, DiffusionCon { } - void operator()(); - DiffusionConnectionEvent* clone() const; + void operator()() override; + DiffusionConnectionEvent* clone() const override; void - set_diffusion_factor( weight t ) + set_diffusion_factor( weight t ) override { diffusion_factor_ = t; }; void - set_drift_factor( weight t ) + set_drift_factor( weight t ) override { drift_factor_ = t; }; @@ -1319,19 +1319,19 @@ Event::set_sender_node_id_info( const thread tid, const synindex syn_id, const i } inline Node& -Event::get_receiver( void ) const +Event::get_receiver( ) const { return *receiver_; } inline Node& -Event::get_sender( void ) const +Event::get_sender( ) const { return *sender_; } inline index -Event::get_sender_node_id( void ) const +Event::get_sender_node_id( ) const { assert( sender_node_id_ > 0 ); return sender_node_id_; diff --git a/nestkernel/event_delivery_manager.h b/nestkernel/event_delivery_manager.h index 555baf8ce8..e4ae4e7792 100644 --- a/nestkernel/event_delivery_manager.h +++ b/nestkernel/event_delivery_manager.h @@ -57,13 +57,13 @@ class EventDeliveryManager : public ManagerInterface { public: EventDeliveryManager(); - virtual ~EventDeliveryManager(); + ~EventDeliveryManager() override; - virtual void initialize() override; - virtual void finalize() override; - virtual void change_number_of_threads() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void change_number_of_threads() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Standard routine for sending events. This method decides if diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index 84f3a91f92..be5c729025 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -101,10 +101,10 @@ class UnknownModelName : public KernelException { } - ~UnknownModelName() throw() + ~UnknownModelName() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -124,10 +124,10 @@ class UnknownComponent : public KernelException { } - ~UnknownComponent() throw() + ~UnknownComponent() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -145,10 +145,10 @@ class NewModelNameExists : public KernelException , n_( n ) { } - ~NewModelNameExists() throw() + ~NewModelNameExists() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -169,10 +169,10 @@ class ModelInUse : public KernelException { } - ~ModelInUse() throw() + ~ModelInUse() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -200,11 +200,11 @@ class UnknownSynapseType : public KernelException { } - ~UnknownSynapseType() throw() + ~UnknownSynapseType() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -232,11 +232,11 @@ class UnknownNode : public KernelException { } - ~UnknownNode() throw() + ~UnknownNode() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -264,11 +264,11 @@ class NoThreadSiblingsAvailable : public KernelException { } - ~NoThreadSiblingsAvailable() throw() + ~NoThreadSiblingsAvailable() throw() override { } - std::string message() const; + std::string message() const override; }; @@ -283,11 +283,11 @@ class LocalNodeExpected : public KernelException { } - ~LocalNodeExpected() throw() + ~LocalNodeExpected() throw() override { } - std::string message() const; + std::string message() const override; }; class NodeWithProxiesExpected : public KernelException @@ -301,11 +301,11 @@ class NodeWithProxiesExpected : public KernelException { } - ~NodeWithProxiesExpected() throw() + ~NodeWithProxiesExpected() throw() override { } - std::string message() const; + std::string message() const override; }; /* @@ -325,10 +325,10 @@ class UnknownCompartment : public KernelException { } - ~UnknownCompartment() throw() + ~UnknownCompartment() throw() override { } - std::string message() const; + std::string message() const override; }; @@ -350,10 +350,10 @@ class UnknownReceptorType : public KernelException { } - ~UnknownReceptorType() throw() + ~UnknownReceptorType() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -376,10 +376,10 @@ class IncompatibleReceptorType : public KernelException { } - ~IncompatibleReceptorType() throw() + ~IncompatibleReceptorType() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -407,11 +407,11 @@ class UnknownPort : public KernelException { } - ~UnknownPort() throw() + ~UnknownPort() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -435,11 +435,11 @@ class IllegalConnection : public KernelException { } - ~IllegalConnection() throw() + ~IllegalConnection() throw() override { } - std::string message() const; + std::string message() const override; private: std::string msg_; @@ -467,11 +467,11 @@ class InexistentConnection : public KernelException { } - ~InexistentConnection() throw() + ~InexistentConnection() throw() override { } - std::string message() const; + std::string message() const override; private: std::string msg_; @@ -492,11 +492,11 @@ class UnknownThread : public KernelException { } - ~UnknownThread() throw() + ~UnknownThread() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -517,11 +517,11 @@ class BadDelay : public KernelException { } - ~BadDelay() throw() + ~BadDelay() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -544,11 +544,11 @@ class UnexpectedEvent : public KernelException { } - ~UnexpectedEvent() throw() + ~UnexpectedEvent() throw() override { } - std::string message() const; + std::string message() const override; private: std::string msg_; @@ -569,10 +569,10 @@ class UnsupportedEvent : public KernelException { } - ~UnsupportedEvent() throw() + ~UnsupportedEvent() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -598,11 +598,11 @@ class BadProperty : public KernelException { } - ~BadProperty() throw() + ~BadProperty() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -628,11 +628,11 @@ class BadParameter : public KernelException { } - ~BadParameter() throw() + ~BadParameter() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -652,7 +652,7 @@ class DimensionMismatch : public KernelException : KernelException( "DimensionMismatch" ) , expected_( -1 ) , provided_( -1 ) - , msg_( "" ) + , { } @@ -660,7 +660,7 @@ class DimensionMismatch : public KernelException : KernelException( "DimensionMismatch" ) , expected_( expected ) , provided_( provided ) - , msg_( "" ) + , { } @@ -673,11 +673,11 @@ class DimensionMismatch : public KernelException } - ~DimensionMismatch() throw() + ~DimensionMismatch() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -692,11 +692,11 @@ class DistributionError : public KernelException : KernelException( "DistributionError" ) { } - ~DistributionError() throw() + ~DistributionError() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -723,11 +723,11 @@ class InvalidDefaultResolution : public KernelException , val_( value ) { } - ~InvalidDefaultResolution() throw() + ~InvalidDefaultResolution() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -759,11 +759,11 @@ class InvalidTimeInModel : public KernelException , val_( value ) { } - ~InvalidTimeInModel() throw() + ~InvalidTimeInModel() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -793,11 +793,11 @@ class StepMultipleRequired : public KernelException , val_( value ) { } - ~StepMultipleRequired() throw() + ~StepMultipleRequired() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -835,11 +835,11 @@ class TimeMultipleRequired : public KernelException , val_b_( value_b ) { } - ~TimeMultipleRequired() throw() + ~TimeMultipleRequired() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -868,11 +868,11 @@ class GSLSolverFailure : public KernelException , status_( status ) { } - ~GSLSolverFailure() throw() + ~GSLSolverFailure() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -896,11 +896,11 @@ class NumericalInstability : public KernelException , model_( model ) { } - ~NumericalInstability() throw() + ~NumericalInstability() throw() override { } - std::string message() const; + std::string message() const override; private: const std::string model_; @@ -926,10 +926,10 @@ class KeyError : public KernelException { } - ~KeyError() throw() + ~KeyError() throw() override { } - std::string message() const; + std::string message() const override; }; /** @@ -953,11 +953,11 @@ class InternalError : public KernelException { } - ~InternalError() throw() + ~InternalError() throw() override { } - std::string message() const; + std::string message() const override; }; @@ -1198,7 +1198,7 @@ class UnmatchedSteps : public KernelException { } - std::string message() const; + std::string message() const override; private: const int current_step_; @@ -1219,7 +1219,7 @@ class BackendPrepared : public KernelException } - std::string message() const; + std::string message() const override; private: const std::string backend_; @@ -1238,7 +1238,7 @@ class BackendNotPrepared : public KernelException { } - std::string message() const; + std::string message() const override; private: const std::string backend_; @@ -1251,11 +1251,11 @@ class LayerExpected : public KernelException : KernelException( "LayerExpected" ) { } - ~LayerExpected() throw() + ~LayerExpected() throw() override { } - std::string message() const; + std::string message() const override; }; class LayerNodeExpected : public KernelException @@ -1265,11 +1265,11 @@ class LayerNodeExpected : public KernelException : KernelException( "LayerNodeExpected" ) { } - ~LayerNodeExpected() throw() + ~LayerNodeExpected() throw() override { } - std::string message() const; + std::string message() const override; }; } // namespace nest diff --git a/nestkernel/genericmodel.h b/nestkernel/genericmodel.h index 56aed02aee..dada55f7a8 100644 --- a/nestkernel/genericmodel.h +++ b/nestkernel/genericmodel.h @@ -54,12 +54,12 @@ class GenericModel : public Model /** * Return pointer to cloned model with same name. */ - Model* clone( const std::string& ) const; + Model* clone( const std::string& ) const override; - bool has_proxies(); - bool one_node_per_process(); - bool is_off_grid(); - void calibrate_time( const TimeConverter& tc ); + bool has_proxies() override; + bool one_node_per_process() override; + bool is_off_grid() override; + void calibrate_time( const TimeConverter& tc ) override; /** @note The decision of whether one node can receive a certain event was originally in the node. But in the distributed case, @@ -74,36 +74,36 @@ class GenericModel : public Model model they represent, they can now answer a call to check connection by referring back to the model. */ - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void sends_secondary_event( GapJunctionEvent& ge ); + void sends_secondary_event( GapJunctionEvent& ge ) override; - SignalType sends_signal() const; + SignalType sends_signal() const override; - void sends_secondary_event( InstantaneousRateConnectionEvent& re ); + void sends_secondary_event( InstantaneousRateConnectionEvent& re ) override; - void sends_secondary_event( DiffusionConnectionEvent& de ); + void sends_secondary_event( DiffusionConnectionEvent& de ) override; - void sends_secondary_event( DelayedRateConnectionEvent& re ); + void sends_secondary_event( DelayedRateConnectionEvent& re ) override; - Node const& get_prototype() const; + Node const& get_prototype() const override; - void set_model_id( int ); + void set_model_id( int ) override; - int get_model_id(); + int get_model_id() override; - void deprecation_warning( const std::string& ); + void deprecation_warning( const std::string& ) override; private: - void set_status_( DictionaryDatum ); - DictionaryDatum get_status_(); + void set_status_( DictionaryDatum ) override; + DictionaryDatum get_status_() override; - size_t get_element_size() const; + size_t get_element_size() const override; /** * Call placement new on the supplied memory position. */ - Node* create_(); + Node* create_() override; /** * Prototype node from which all instances are constructed. diff --git a/nestkernel/grid_mask.h b/nestkernel/grid_mask.h index 53757ef38b..7c76c0abe4 100644 --- a/nestkernel/grid_mask.h +++ b/nestkernel/grid_mask.h @@ -54,14 +54,14 @@ class GridMask : public AbstractMask GridMask( const DictionaryDatum& d ); bool - inside( const std::vector< double >& ) const + inside( const std::vector< double >& ) const override { throw KernelException( "Grid mask must be applied to a grid layer." ); } void set_anchor( const Position< D, int >& ); - DictionaryDatum get_dict() const; + DictionaryDatum get_dict() const override; GridMask< D >* clone() const @@ -75,19 +75,19 @@ class GridMask : public AbstractMask static Name get_name(); AbstractMask* - intersect_mask( const AbstractMask& ) const + intersect_mask( const AbstractMask& ) const override { throw KernelException( "Grid masks can not be combined." ); } AbstractMask* - union_mask( const AbstractMask& ) const + union_mask( const AbstractMask& ) const override { throw KernelException( "Grid masks can not be combined." ); } AbstractMask* - minus_mask( const AbstractMask& ) const + minus_mask( const AbstractMask& ) const override { throw KernelException( "Grid masks can not be combined." ); } diff --git a/nestkernel/growth_curve.h b/nestkernel/growth_curve.h index 5f860e8ac0..cdd90daa1f 100644 --- a/nestkernel/growth_curve.h +++ b/nestkernel/growth_curve.h @@ -131,9 +131,9 @@ class GrowthCurveLinear : public GrowthCurve { public: GrowthCurveLinear(); - void get( DictionaryDatum& d ) const; - void set( const DictionaryDatum& d ); - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const; + void get( DictionaryDatum& d ) const override; + void set( const DictionaryDatum& d ) override; + double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eps_; @@ -218,9 +218,9 @@ class GrowthCurveGaussian : public GrowthCurve { public: GrowthCurveGaussian(); - void get( DictionaryDatum& d ) const; - void set( const DictionaryDatum& d ); - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const; + void get( DictionaryDatum& d ) const override; + void set( const DictionaryDatum& d ) override; + double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eta_; @@ -290,9 +290,9 @@ class GrowthCurveSigmoid : public GrowthCurve { public: GrowthCurveSigmoid(); - void get( DictionaryDatum& d ) const; - void set( const DictionaryDatum& d ); - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const; + void get( DictionaryDatum& d ) const override; + void set( const DictionaryDatum& d ) override; + double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eps_; diff --git a/nestkernel/io_manager.cpp b/nestkernel/io_manager.cpp index 714c1d3e40..e998604003 100644 --- a/nestkernel/io_manager.cpp +++ b/nestkernel/io_manager.cpp @@ -83,7 +83,7 @@ IOManager::set_data_path_prefix_( const DictionaryDatum& dict ) if ( updateValue< std::string >( dict, names::data_path, tmp ) ) { DIR* testdir = opendir( tmp.c_str() ); - if ( testdir != NULL ) + if ( testdir != nullptr ) { data_path_ = tmp; // absolute path & directory exists closedir( testdir ); // we only opened it to check it exists diff --git a/nestkernel/layer.cpp b/nestkernel/layer.cpp index 27e817d250..530fcba67c 100644 --- a/nestkernel/layer.cpp +++ b/nestkernel/layer.cpp @@ -44,8 +44,8 @@ namespace nest { -NodeCollectionMetadataPTR AbstractLayer::cached_ntree_md_ = NodeCollectionMetadataPTR( 0 ); -NodeCollectionMetadataPTR AbstractLayer::cached_vector_md_ = NodeCollectionMetadataPTR( 0 ); +NodeCollectionMetadataPTR AbstractLayer::cached_ntree_md_ = NodeCollectionMetadataPTR( nullptr ); +NodeCollectionMetadataPTR AbstractLayer::cached_vector_md_ = NodeCollectionMetadataPTR( nullptr ); AbstractLayer::~AbstractLayer() { @@ -55,7 +55,7 @@ NodeCollectionPTR AbstractLayer::create_layer( const DictionaryDatum& layer_dict ) { index length = 0; - AbstractLayer* layer_local = 0; + AbstractLayer* layer_local = nullptr; auto element_name = getValue< std::string >( layer_dict, names::elements ); auto element_id = kernel().model_manager.get_node_model_id( element_name ); diff --git a/nestkernel/layer.h b/nestkernel/layer.h index 0d0416d0cc..9a090a9c63 100644 --- a/nestkernel/layer.h +++ b/nestkernel/layer.h @@ -57,7 +57,7 @@ class AbstractLayer * Constructor. */ AbstractLayer() - : node_collection_( NodeCollectionPTR( 0 ) ) + : node_collection_( NodeCollectionPTR( nullptr ) ) { } @@ -228,24 +228,24 @@ class Layer : public AbstractLayer /** * Virtual destructor */ - ~Layer(); + ~Layer() override; /** * Change properties of the layer according to the * entries in the dictionary. * @param d Dictionary with named parameter settings. */ - void set_status( const DictionaryDatum& ); + void set_status( const DictionaryDatum& ) override; /** * Export properties of the layer by setting * entries in the status dictionary. * @param d Dictionary. */ - void get_status( DictionaryDatum& ) const; + void get_status( DictionaryDatum& ) const override; unsigned int - get_num_dimensions() const + get_num_dimensions() const override { return D; } @@ -297,7 +297,7 @@ class Layer : public AbstractLayer * @param sind index of node * @returns position of node as std::vector */ - std::vector< double > get_position_vector( const index sind ) const; + std::vector< double > get_position_vector( const index sind ) const override; /** * Returns displacement of a position from another position. When using @@ -320,7 +320,7 @@ class Layer : public AbstractLayer */ Position< D > compute_displacement( const Position< D >& from_pos, const index to ) const; - std::vector< double > compute_displacement( const std::vector< double >& from_pos, const index to ) const; + std::vector< double > compute_displacement( const std::vector< double >& from_pos, const index to ) const override; /** * Returns distance to node from given position. When using periodic @@ -331,9 +331,9 @@ class Layer : public AbstractLayer */ double compute_distance( const Position< D >& from_pos, const index lid ) const; - double compute_distance( const std::vector< double >& from_pos, const index lid ) const; + double compute_distance( const std::vector< double >& from_pos, const index lid ) const override; - double compute_distance( const std::vector< double >& from_pos, const std::vector< double >& to_pos ) const; + double compute_distance( const std::vector< double >& from_pos, const std::vector< double >& to_pos ) const override; /** @@ -369,7 +369,7 @@ class Layer : public AbstractLayer std::vector< index > get_global_nodes( const MaskDatum& mask, const std::vector< double >& anchor, bool allow_oversized, - NodeCollectionPTR node_collection ); + NodeCollectionPTR node_collection ) override; /** * Connect this layer to the given target layer. The actual connections @@ -383,7 +383,7 @@ class Layer : public AbstractLayer void connect( NodeCollectionPTR source_nc, AbstractLayerPTR target, NodeCollectionPTR target_nc, - ConnectionCreator& connector ); + ConnectionCreator& connector ) override; /** * Write layer data to stream. @@ -391,7 +391,7 @@ class Layer : public AbstractLayer * node ID x-position y-position [z-position] * @param os output stream */ - void dump_nodes( std::ostream& os ) const; + void dump_nodes( std::ostream& os ) const override; /** * Dumps information about all connections of the given type having their @@ -406,18 +406,18 @@ class Layer : public AbstractLayer void dump_connections( std::ostream& out, NodeCollectionPTR node_collection, AbstractLayerPTR target_layer, - const Token& syn_model ); + const Token& syn_model ) override; protected: /** * Clear the cache for global position information */ - void clear_ntree_cache_() const; + void clear_ntree_cache_() const override; /** * Clear the cache for global position information */ - void clear_vector_cache_() const; + void clear_vector_cache_() const override; std::shared_ptr< Ntree< D, index > > do_get_global_positions_ntree_( NodeCollectionPTR node_collection ); @@ -666,7 +666,7 @@ inline void Layer< D >::clear_ntree_cache_() const { cached_ntree_ = std::shared_ptr< Ntree< D, index > >(); - cached_ntree_md_ = NodeCollectionMetadataPTR( 0 ); + cached_ntree_md_ = NodeCollectionMetadataPTR( nullptr ); } template < int D > @@ -678,7 +678,7 @@ Layer< D >::clear_vector_cache_() const delete cached_vector_; } cached_vector_ = 0; - cached_vector_md_ = NodeCollectionMetadataPTR( 0 ); + cached_vector_md_ = NodeCollectionMetadataPTR( nullptr ); } } // namespace nest diff --git a/nestkernel/logging_manager.cpp b/nestkernel/logging_manager.cpp index 7ee54d3978..856312324c 100644 --- a/nestkernel/logging_manager.cpp +++ b/nestkernel/logging_manager.cpp @@ -68,7 +68,7 @@ nest::LoggingManager::get_status( DictionaryDatum& dict ) void nest::LoggingManager::register_logging_client( const deliver_logging_event_ptr callback ) { - assert( callback != 0 ); + assert( callback != nullptr ); client_callbacks_.push_back( callback ); } diff --git a/nestkernel/logging_manager.h b/nestkernel/logging_manager.h index e9a5d78047..d21ed812fb 100644 --- a/nestkernel/logging_manager.h +++ b/nestkernel/logging_manager.h @@ -49,10 +49,10 @@ class LoggingManager : public ManagerInterface public: LoggingManager(); - virtual void initialize() override; - virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Register a logging client. diff --git a/nestkernel/mask.h b/nestkernel/mask.h index f1b149ed4f..c8409411b4 100644 --- a/nestkernel/mask.h +++ b/nestkernel/mask.h @@ -104,7 +104,7 @@ class Mask : public AbstractMask public: using AbstractMask::inside; - ~Mask() + ~Mask() override { } @@ -116,7 +116,7 @@ class Mask : public AbstractMask /** * @returns true if point is inside mask. */ - bool inside( const std::vector< double >& pt ) const; + bool inside( const std::vector< double >& pt ) const override; /** * @returns true if the whole box is inside the mask. @@ -144,9 +144,9 @@ class Mask : public AbstractMask */ virtual Mask* clone() const = 0; - AbstractMask* intersect_mask( const AbstractMask& other ) const; - AbstractMask* union_mask( const AbstractMask& other ) const; - AbstractMask* minus_mask( const AbstractMask& other ) const; + AbstractMask* intersect_mask( const AbstractMask& other ) const override; + AbstractMask* union_mask( const AbstractMask& other ) const override; + AbstractMask* minus_mask( const AbstractMask& other ) const override; }; /** @@ -225,7 +225,7 @@ class BoxMask : public Mask< D > const double azimuth_angle = 0.0, const double polar_angle = 0.0 ); - ~BoxMask() + ~BoxMask() override { } @@ -234,23 +234,23 @@ class BoxMask : public Mask< D > /** * @returns true if point is inside the box */ - bool inside( const Position< D >& p ) const; + bool inside( const Position< D >& p ) const override; /** * @returns true if the whole given box is inside this box */ - bool inside( const Box< D >& b ) const; + bool inside( const Box< D >& b ) const override; /** * @returns true if the whole given box is outside this box */ - bool outside( const Box< D >& b ) const; + bool outside( const Box< D >& b ) const override; - Box< D > get_bbox() const; + Box< D > get_bbox() const override; - DictionaryDatum get_dict() const; + DictionaryDatum get_dict() const override; - Mask< D >* clone() const; + Mask< D >* clone() const override; /** * @returns the name of this mask type. @@ -326,7 +326,7 @@ class BallMask : public Mask< D > */ BallMask( const DictionaryDatum& ); - ~BallMask() + ~BallMask() override { } @@ -335,23 +335,23 @@ class BallMask : public Mask< D > /** * @returns true if point is inside the circle */ - bool inside( const Position< D >& p ) const; + bool inside( const Position< D >& p ) const override; /** * @returns true if the whole box is inside the circle */ - bool inside( const Box< D >& ) const; + bool inside( const Box< D >& ) const override; /** * @returns true if the whole box is outside the circle */ - bool outside( const Box< D >& b ) const; + bool outside( const Box< D >& b ) const override; - Box< D > get_bbox() const; + Box< D > get_bbox() const override; - DictionaryDatum get_dict() const; + DictionaryDatum get_dict() const override; - Mask< D >* clone() const; + Mask< D >* clone() const override; /** * @returns the name of this mask type. @@ -431,7 +431,7 @@ class EllipseMask : public Mask< D > */ EllipseMask( const DictionaryDatum& ); - ~EllipseMask() + ~EllipseMask() override { } @@ -440,23 +440,23 @@ class EllipseMask : public Mask< D > /** * @returns true if point is inside the ellipse */ - bool inside( const Position< D >& p ) const; + bool inside( const Position< D >& p ) const override; /** * @returns true if the whole box is inside the ellipse */ - bool inside( const Box< D >& ) const; + bool inside( const Box< D >& ) const override; /** * @returns true if the whole box is outside the ellipse */ - bool outside( const Box< D >& b ) const; + bool outside( const Box< D >& b ) const override; - Box< D > get_bbox() const; + Box< D > get_bbox() const override; - DictionaryDatum get_dict() const; + DictionaryDatum get_dict() const override; - Mask< D >* clone() const; + Mask< D >* clone() const override; /** * @returns the name of this mask type. diff --git a/nestkernel/model.cpp b/nestkernel/model.cpp index dc8db69e61..602452ffa5 100644 --- a/nestkernel/model.cpp +++ b/nestkernel/model.cpp @@ -118,7 +118,7 @@ Model::set_status( DictionaryDatum d ) } DictionaryDatum -Model::get_status( void ) +Model::get_status( ) { DictionaryDatum d = get_status_(); diff --git a/nestkernel/model.h b/nestkernel/model.h index dcd3810596..6f780dc90b 100644 --- a/nestkernel/model.h +++ b/nestkernel/model.h @@ -143,7 +143,7 @@ class Model * @param d Dictionary. * @ingroup status_interface */ - DictionaryDatum get_status( void ); + DictionaryDatum get_status( ); virtual port send_test_event( Node&, rport, synindex, bool ) = 0; @@ -168,7 +168,7 @@ class Model /** * Return const reference to the prototype. */ - virtual Node const& get_prototype( void ) const = 0; + virtual Node const& get_prototype( ) const = 0; /** * Set the model id on the prototype. diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 041de0d811..68a42da972 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -49,7 +49,7 @@ ModelManager::ModelManager() , connection_models_() , modeldict_( new Dictionary ) , synapsedict_( new Dictionary ) - , proxynode_model_( 0 ) + , proxynode_model_( nullptr ) , proxy_nodes_() , model_defaults_modified_( false ) { @@ -79,7 +79,7 @@ ModelManager::~ModelManager() void ModelManager::initialize() { - if ( proxynode_model_ == 0 ) + if ( proxynode_model_ == nullptr ) { proxynode_model_ = new GenericModel< proxynode >( "proxynode", "" ); proxynode_model_->set_type_id( 1 ); @@ -380,7 +380,7 @@ ModelManager::get_node_model_id( const Name name ) const const Name model_name( name ); for ( int i = 0; i < ( int ) node_models_.size(); ++i ) { - assert( node_models_[ i ] != 0 ); + assert( node_models_[ i ] != nullptr ); if ( model_name == node_models_[ i ]->get_name() ) { return i; @@ -459,7 +459,7 @@ ModelManager::clear_node_models_() } delete proxynode_model_; - proxynode_model_ = 0; + proxynode_model_ = nullptr; node_models_.clear(); proxy_nodes_.clear(); diff --git a/nestkernel/model_manager.h b/nestkernel/model_manager.h index e5e173517d..20b6de027c 100644 --- a/nestkernel/model_manager.h +++ b/nestkernel/model_manager.h @@ -46,7 +46,7 @@ class ModelManager : public ManagerInterface { public: ModelManager(); - ~ModelManager(); + ~ModelManager() override; virtual void initialize() override; virtual void finalize() override; @@ -325,7 +325,7 @@ ModelManager::get_num_connection_models() const inline void ModelManager::assert_valid_syn_id( synindex syn_id, thread t ) const { - if ( syn_id >= connection_models_[ t ].size() or connection_models_[ t ][ syn_id ] == 0 ) + if ( syn_id >= connection_models_[ t ].size() or connection_models_[ t ][ syn_id ] == nullptr ) { throw UnknownSynapseType( syn_id ); } diff --git a/nestkernel/model_manager_impl.h b/nestkernel/model_manager_impl.h index fd6bf04bf7..565a97c646 100644 --- a/nestkernel/model_manager_impl.h +++ b/nestkernel/model_manager_impl.h @@ -115,7 +115,7 @@ ModelManager::register_secondary_connection_model( const std::string& name, cons // elements if ( secondary_connector_models_.size() < syn_id + ( unsigned int ) 1 ) { - secondary_connector_models_.resize( syn_id + 1, NULL ); + secondary_connector_models_.resize( syn_id + 1, nullptr ); } secondary_connector_models_[ syn_id ] = cm; @@ -135,7 +135,7 @@ ModelManager::register_secondary_connection_model( const std::string& name, cons // elements if ( secondary_connector_models_.size() < syn_id + ( unsigned int ) 1 ) { - secondary_connector_models_.resize( syn_id + 1, NULL ); + secondary_connector_models_.resize( syn_id + 1, nullptr ); } secondary_connector_models_[ syn_id ] = cm; diff --git a/nestkernel/modelrange_manager.h b/nestkernel/modelrange_manager.h index 0a6b4b0f57..5be6bfe943 100644 --- a/nestkernel/modelrange_manager.h +++ b/nestkernel/modelrange_manager.h @@ -41,7 +41,7 @@ class ModelRangeManager : public ManagerInterface { public: ModelRangeManager(); - ~ModelRangeManager() + ~ModelRangeManager() override { } diff --git a/nestkernel/mpi_manager.h b/nestkernel/mpi_manager.h index 70723c4e67..8f0690788a 100644 --- a/nestkernel/mpi_manager.h +++ b/nestkernel/mpi_manager.h @@ -61,7 +61,7 @@ class MPIManager : public ManagerInterface class OffGridSpike; MPIManager(); - ~MPIManager() + ~MPIManager() override { } diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index c4b6cdacf5..23ec0f87aa 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -95,13 +95,13 @@ NestModule::~NestModule() // The following concerns the new module: const std::string -NestModule::name( void ) const +NestModule::name( ) const { return std::string( "NEST Kernel 2" ); // Return name of the module } const std::string -NestModule::commandstring( void ) const +NestModule::commandstring( ) const { return std::string( "(nest-init) run" ); } @@ -156,7 +156,7 @@ NestModule::create_parameter( const Name& name, const DictionaryDatum& d ) } GenericFactory< Parameter >& -NestModule::parameter_factory_( void ) +NestModule::parameter_factory_( ) { static GenericFactory< Parameter > factory; return factory; @@ -164,7 +164,7 @@ NestModule::parameter_factory_( void ) GenericFactory< AbstractMask >& -NestModule::mask_factory_( void ) +NestModule::mask_factory_( ) { static GenericFactory< AbstractMask > factory; return factory; @@ -184,7 +184,7 @@ NestModule::create_mask( const Token& t ) { DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( t.datum() ); - if ( dd == 0 ) + if ( dd == nullptr ) { throw BadProperty( "Mask must be masktype or dictionary." ); } @@ -195,7 +195,7 @@ NestModule::create_mask( const Token& t ) // anchor key will be stored in the anchor_token variable. Token anchor_token; bool has_anchor = false; - AbstractMask* mask = 0; + AbstractMask* mask = nullptr; for ( Dictionary::iterator dit = ( *dd )->begin(); dit != ( *dd )->end(); ++dit ) { @@ -209,7 +209,7 @@ NestModule::create_mask( const Token& t ) else { - if ( mask != 0 ) + if ( mask != nullptr ) { // mask has already been defined throw BadProperty( "Mask definition dictionary contains extraneous items." ); } diff --git a/nestkernel/nestmodule.h b/nestkernel/nestmodule.h index 9c39cd72f9..88d91f9058 100644 --- a/nestkernel/nestmodule.h +++ b/nestkernel/nestmodule.h @@ -68,12 +68,12 @@ class NestModule : public SLIModule static SLIType ParameterType; NestModule(); - ~NestModule(); + ~NestModule() override; - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; - const std::string commandstring( void ) const; - const std::string name( void ) const; + const std::string commandstring( ) const override; + const std::string name( ) const override; static sharedPtrDatum< Parameter, &ParameterType > create_parameter( const Token& ); static Parameter* create_parameter( const Name& name, const DictionaryDatum& d ); @@ -200,211 +200,211 @@ class NestModule : public SLIModule class GetStatus_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getstatus_gfunction; class GetStatus_iFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getstatus_ifunction; class GetStatus_CFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getstatus_Cfunction; class GetStatus_aFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getstatus_afunction; class GetMetadata_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getmetadata_gfunction; class GetKernelStatus_Function : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getkernelstatus_function; class SetStatus_idFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setstatus_idfunction; class SetStatus_CDFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setstatus_CDfunction; class SetKernelStatus_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setkernelstatus_Dfunction; class Cva_CFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cva_cfunction; class SetStatus_aaFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setstatus_aafunction; class SetDefaults_l_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setdefaults_l_Dfunction; class GetDefaults_lFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getdefaults_lfunction; class CopyModel_l_l_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } copymodel_l_l_Dfunction; class GetConnections_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getconnections_Dfunction; class SimulateFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } simulatefunction; class PrepareFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } preparefunction; class RunFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } runfunction; class CleanupFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cleanupfunction; class Create_l_iFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } create_l_ifunction; class GetNodes_D_b : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getnodes_D_bfunction; class Disconnect_g_g_D_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } disconnect_g_g_D_Dfunction; class Connect_g_g_D_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } connect_g_g_D_Dfunction; class Connect_g_g_D_aFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } connect_g_g_D_afunction; class ResetKernelFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } resetkernelfunction; class MemoryInfoFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } memoryinfofunction; class PrintNodesFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } printnodesfunction; class PrintNodesToStreamFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } printnodestostreamfunction; class RankFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } rankfunction; class NumProcessesFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } numprocessesfunction; class SetFakeNumProcesses_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setfakenumprocesses_ifunction; class SyncProcessesFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } syncprocessesfunction; class TimeCommunication_i_i_bFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } timecommunication_i_i_bfunction; class TimeCommunicationv_i_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } timecommunicationv_i_ifunction; class TimeCommunicationAlltoall_i_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } timecommunicationalltoall_i_ifunction; class TimeCommunicationAlltoallv_i_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } timecommunicationalltoallv_i_ifunction; class ProcessorNameFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } processornamefunction; #ifdef HAVE_MPI @@ -416,102 +416,102 @@ class NestModule : public SLIModule class Cvdict_CFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cvdict_Cfunction; class Cvnodecollection_i_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cvnodecollection_i_ifunction; class Cvnodecollection_iaFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cvnodecollection_iafunction; class Cvnodecollection_ivFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cvnodecollection_ivfunction; class Cva_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cva_gfunction; class Size_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } size_gfunction; class ValidQ_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } validq_gfunction; class Join_g_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } join_g_gfunction; class MemberQ_g_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } memberq_g_ifunction; class Find_g_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } find_g_ifunction; class eq_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } eq_gfunction; class BeginIterator_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } beginiterator_gfunction; class EndIterator_gFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } enditerator_gfunction; class GetNodeID_qFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getnodeid_qfunction; class GetNodeIDModelID_qFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getnodeidmodelid_qfunction; class Next_qFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } next_qfunction; class Eq_q_qFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } eq_q_qfunction; class Lt_q_qFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } lt_q_qfunction; class Get_g_iFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } get_g_ifunction; class Take_g_aFunction : public SLIFunction { - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } take_g_afunction; #ifdef HAVE_MUSIC @@ -529,139 +529,139 @@ class NestModule : public SLIModule class EnableStructuralPlasticity_Function : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } enablestructuralplasticity_function; class DisableStructuralPlasticity_Function : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } disablestructuralplasticity_function; class SetStdpEps_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } setstdpeps_dfunction; class Mul_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } mul_P_Pfunction; class Div_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } div_P_Pfunction; class Add_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } add_P_Pfunction; class Sub_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } sub_P_Pfunction; class Compare_P_P_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } compare_P_P_Dfunction; class Conditional_P_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } conditional_P_P_Pfunction; class Min_P_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } min_P_dfunction; class Max_P_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } max_P_dfunction; class Redraw_P_d_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } redraw_P_d_dfunction; class Exp_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } exp_Pfunction; class Sin_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } sin_Pfunction; class Cos_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cos_Pfunction; class Pow_P_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } pow_P_dfunction; class Dimension2d_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } dimension2d_P_Pfunction; class Dimension3d_P_P_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } dimension3d_P_P_Pfunction; class CreateParameter_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } createparameter_Dfunction; class GetValue_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getvalue_Pfunction; class IsSpatial_PFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } isspatial_Pfunction; class Apply_P_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } apply_P_Dfunction; class Apply_P_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } apply_P_gfunction; #ifdef HAVE_LIBNEUROSIM @@ -688,109 +688,109 @@ class NestModule : public SLIModule class CreateLayer_D_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } createlayer_D_Dfunction; class GetPosition_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getposition_gfunction; class Displacement_g_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } displacement_g_gfunction; class Displacement_a_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } displacement_a_gfunction; class Distance_g_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } distance_g_gfunction; class Distance_a_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } distance_a_gfunction; class Distance_aFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } distance_afunction; class ConnectLayers_g_g_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } connectlayers_g_g_Dfunction; class CreateMask_DFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } createmask_Dfunction; class GetLayerStatus_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } getlayerstatus_gfunction; class Inside_a_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } inside_a_Mfunction; class And_M_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } and_M_Mfunction; class Or_M_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } or_M_Mfunction; class Sub_M_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } sub_M_Mfunction; class DumpLayerNodes_os_gFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } dumplayernodes_os_gfunction; class DumpLayerConnections_os_g_g_lFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } dumplayerconnections_os_g_g_lfunction; class Cvdict_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } cvdict_Mfunction; class SelectNodesByMask_g_a_MFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; } selectnodesbymask_g_a_Mfunction; private: diff --git a/nestkernel/node.cpp b/nestkernel/node.cpp index 0a5c154638..a387e2560c 100644 --- a/nestkernel/node.cpp +++ b/nestkernel/node.cpp @@ -336,7 +336,6 @@ port Node::handles_test_event( GapJunctionEvent&, rport ) { throw IllegalConnection( "The target node or synapse model does not support gap junction input." ); - return invalid_port; } void @@ -355,7 +354,6 @@ port Node::handles_test_event( InstantaneousRateConnectionEvent&, rport ) { throw IllegalConnection( "The target node or synapse model does not support instantaneous rate input." ); - return invalid_port; } void @@ -374,7 +372,6 @@ port Node::handles_test_event( DiffusionConnectionEvent&, rport ) { throw IllegalConnection( "The target node or synapse model does not support diffusion input." ); - return invalid_port; } void @@ -393,7 +390,6 @@ port Node::handles_test_event( DelayedRateConnectionEvent&, rport ) { throw IllegalConnection( "The target node or synapse model does not support delayed rate input." ); - return invalid_port; } void diff --git a/nestkernel/node.h b/nestkernel/node.h index e0b36962c5..9cb9674a13 100644 --- a/nestkernel/node.h +++ b/nestkernel/node.h @@ -125,7 +125,7 @@ class Node virtual Node* clone() const { - return 0; + return nullptr; } /** diff --git a/nestkernel/node_collection.cpp b/nestkernel/node_collection.cpp index 2914e71345..363cd408ca 100644 --- a/nestkernel/node_collection.cpp +++ b/nestkernel/node_collection.cpp @@ -506,7 +506,7 @@ NodeCollectionPrimitive::print_primitive( std::ostream& out ) const } bool -NodeCollectionPrimitive::is_contiguous_ascending( NodeCollectionPrimitive& other ) +NodeCollectionPrimitive::is_contiguous_ascending( NodeCollectionPrimitive& other ) const { return ( ( last_ + 1 ) == other.first_ ) and ( model_id_ == other.model_id_ ); } diff --git a/nestkernel/node_collection.h b/nestkernel/node_collection.h index 2704315ef9..937b9bacc6 100644 --- a/nestkernel/node_collection.h +++ b/nestkernel/node_collection.h @@ -488,7 +488,7 @@ class NodeCollectionPrimitive : public NodeCollection * the last element in this primitive, and they both have the same model ID. * Otherwise false. */ - bool is_contiguous_ascending( NodeCollectionPrimitive& other ); + bool is_contiguous_ascending( NodeCollectionPrimitive& other ) const; /** * Checks if node IDs of another primitive is overlapping node IDs of this primitive diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index 7ce920c466..a96e4eb498 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -94,7 +94,7 @@ NodeManager::get_status( index idx ) { Node* target = get_mpi_local_node_or_device_head( idx ); - assert( target != 0 ); + assert( target != nullptr ); DictionaryDatum d = target->get_status_base(); @@ -114,7 +114,7 @@ NodeManager::add_node( index model_id, long n ) } Model* model = kernel().model_manager.get_node_model( model_id ); - assert( model != 0 ); + assert( model != nullptr ); model->deprecation_warning( "Create" ); const index min_node_id = local_nodes_.at( 0 ).get_max_node_id() + 1; @@ -425,7 +425,7 @@ NodeManager::get_node_or_proxy( index node_id, thread t ) assert( 0 < node_id and node_id <= size() ); Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == 0 ) + if ( node == nullptr ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -446,7 +446,7 @@ NodeManager::get_node_or_proxy( index node_id ) thread t = kernel().vp_manager.vp_to_thread( vp ); Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == 0 ) + if ( node == nullptr ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -461,7 +461,7 @@ NodeManager::get_mpi_local_node_or_device_head( index node_id ) Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == 0 ) + if ( node == nullptr ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -481,7 +481,7 @@ NodeManager::get_thread_siblings( index node_id ) const for ( size_t t = 0; t < num_threads; ++t ) { Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == 0 ) + if ( node == nullptr ) { throw NoThreadSiblingsAvailable( node_id ); } @@ -753,7 +753,7 @@ NodeManager::set_status( index node_id, const DictionaryDatum& d ) for ( thread t = 0; t < kernel().vp_manager.get_num_threads(); ++t ) { Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node != 0 ) + if ( node != nullptr ) { set_status_single_node_( *node, d ); } diff --git a/nestkernel/node_manager.h b/nestkernel/node_manager.h index 034c41e642..a2b6e60ac1 100644 --- a/nestkernel/node_manager.h +++ b/nestkernel/node_manager.h @@ -50,7 +50,7 @@ class NodeManager : public ManagerInterface { public: NodeManager(); - ~NodeManager(); + ~NodeManager() override; virtual void initialize() override; virtual void finalize() override; diff --git a/nestkernel/proxynode.h b/nestkernel/proxynode.h index d0411deed3..4172aad5e7 100644 --- a/nestkernel/proxynode.h +++ b/nestkernel/proxynode.h @@ -77,24 +77,24 @@ class proxynode : public Node using Node::handle; using Node::sends_signal; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void sends_secondary_event( GapJunctionEvent& ); + void sends_secondary_event( GapJunctionEvent& ) override; - SignalType sends_signal() const; + SignalType sends_signal() const override; - void sends_secondary_event( InstantaneousRateConnectionEvent& ); + void sends_secondary_event( InstantaneousRateConnectionEvent& ) override; - void sends_secondary_event( DiffusionConnectionEvent& ); + void sends_secondary_event( DiffusionConnectionEvent& ) override; - void sends_secondary_event( DelayedRateConnectionEvent& ); + void sends_secondary_event( DelayedRateConnectionEvent& ) override; void - handle( SpikeEvent& ) + handle( SpikeEvent& ) override { } - void get_status( DictionaryDatum& ) const; + void get_status( DictionaryDatum& ) const override; /** * Proxy nodes have no properties. @@ -104,15 +104,15 @@ class proxynode : public Node * problems with dictionary entry checking */ void - set_status( const DictionaryDatum& ) + set_status( const DictionaryDatum& ) override { assert( false ); } - bool is_proxy() const; + bool is_proxy() const override; - thread - get_thread() const + static thread + get_thread() { assert( false ); return invalid_thread; @@ -120,19 +120,19 @@ class proxynode : public Node private: void - init_state_() + init_state_() override { } void - init_buffers_() + init_buffers_() override { } void - pre_run_hook() + pre_run_hook() override { } void - update( Time const&, const long, const long ) + update( Time const&, const long, const long ) override { } }; diff --git a/nestkernel/pseudo_recording_device.h b/nestkernel/pseudo_recording_device.h index 725bb9fa45..bd93b10ac2 100644 --- a/nestkernel/pseudo_recording_device.h +++ b/nestkernel/pseudo_recording_device.h @@ -89,7 +89,7 @@ class PseudoRecordingDevice : public Device * The argument is the time stamp of the event, and the * device is active if start_ < T <= stop_. */ - bool is_active( Time const& T ) const; + bool is_active( Time const& T ) const override; }; inline PseudoRecordingDevice::PseudoRecordingDevice() diff --git a/nestkernel/random_manager.h b/nestkernel/random_manager.h index 53a8cd9834..30b910652e 100644 --- a/nestkernel/random_manager.h +++ b/nestkernel/random_manager.h @@ -51,7 +51,7 @@ class RandomManager : public ManagerInterface { public: RandomManager(); - ~RandomManager(); + ~RandomManager() override; /** * Register available RNG types, set default RNG type and create RNGs. diff --git a/nestkernel/recording_backend_ascii.h b/nestkernel/recording_backend_ascii.h index 2b3f8cf978..ab059b7e60 100644 --- a/nestkernel/recording_backend_ascii.h +++ b/nestkernel/recording_backend_ascii.h @@ -153,7 +153,7 @@ class RecordingBackendASCII : public RecordingBackend RecordingBackendASCII(); - ~RecordingBackendASCII() throw(); + ~RecordingBackendASCII() throw() override; void initialize() override; diff --git a/nestkernel/recording_backend_memory.h b/nestkernel/recording_backend_memory.h index 9f07bbc5b8..48fe645db3 100644 --- a/nestkernel/recording_backend_memory.h +++ b/nestkernel/recording_backend_memory.h @@ -113,7 +113,7 @@ class RecordingBackendMemory : public RecordingBackend { public: RecordingBackendMemory(); - ~RecordingBackendMemory() throw(); + ~RecordingBackendMemory() throw() override; void initialize() override; void finalize() override; diff --git a/nestkernel/recording_backend_screen.h b/nestkernel/recording_backend_screen.h index 4843210b86..ec0256618c 100644 --- a/nestkernel/recording_backend_screen.h +++ b/nestkernel/recording_backend_screen.h @@ -85,7 +85,7 @@ class RecordingBackendScreen : public RecordingBackend { } - ~RecordingBackendScreen() throw() + ~RecordingBackendScreen() throw() override { } diff --git a/nestkernel/simulation_manager.cpp b/nestkernel/simulation_manager.cpp index 290ad243b6..051def93e8 100644 --- a/nestkernel/simulation_manager.cpp +++ b/nestkernel/simulation_manager.cpp @@ -790,7 +790,7 @@ nest::SimulationManager::update_() { if ( print_time_ ) { - gettimeofday( &t_slice_begin_, NULL ); + gettimeofday( &t_slice_begin_, nullptr ); } if ( kernel().sp_manager.is_structural_plasticity_enabled() @@ -1015,7 +1015,7 @@ nest::SimulationManager::update_() if ( print_time_ ) { - gettimeofday( &t_slice_end_, NULL ); + gettimeofday( &t_slice_end_, nullptr ); print_progress_(); } diff --git a/nestkernel/sp_manager.cpp b/nestkernel/sp_manager.cpp index 1c4b0497f8..16c4a64b0f 100644 --- a/nestkernel/sp_manager.cpp +++ b/nestkernel/sp_manager.cpp @@ -282,7 +282,7 @@ SPManager::disconnect( NodeCollectionPTR sources, } } - ConnBuilder* cb = NULL; + ConnBuilder* cb = nullptr; conn_spec->clear_access_flags(); syn_spec->clear_access_flags(); @@ -315,7 +315,7 @@ SPManager::disconnect( NodeCollectionPTR sources, { cb = kernel().connection_manager.get_conn_builder( rule_name, sources, targets, conn_spec, { syn_spec } ); } - assert( cb != 0 ); + assert( cb != nullptr ); // at this point, all entries in conn_spec and syn_spec have been checked ALL_ENTRIES_ACCESSED( *conn_spec, "Connect", "Unread dictionary entries: " ); diff --git a/nestkernel/sp_manager_impl.h b/nestkernel/sp_manager_impl.h index a346dcb984..0efdca12ce 100644 --- a/nestkernel/sp_manager_impl.h +++ b/nestkernel/sp_manager_impl.h @@ -41,7 +41,7 @@ SPManager::register_growth_curve( const std::string& name ) { assert( not growthcurvedict_->known( name ) ); GenericGrowthCurveFactory* nc = new GrowthCurveFactory< GrowthCurve >(); - assert( nc != 0 ); + assert( nc != nullptr ); const int id = growthcurve_factories_.size(); growthcurve_factories_.push_back( nc ); growthcurvedict_->insert( name, id ); diff --git a/nestkernel/sparse_node_array.cpp b/nestkernel/sparse_node_array.cpp index fe61db19d6..32636b4873 100644 --- a/nestkernel/sparse_node_array.cpp +++ b/nestkernel/sparse_node_array.cpp @@ -136,7 +136,7 @@ nest::SparseNodeArray::get_node_by_node_id( index node_id ) const // handle node_ids below or above range if ( node_id < local_min_node_id_ or local_max_node_id_ < node_id ) { - return 0; + return nullptr; } /* Find base index and node ID for estimating location of desired node in array. @@ -171,6 +171,6 @@ nest::SparseNodeArray::get_node_by_node_id( index node_id ) const } else { - return 0; + return nullptr; } } diff --git a/nestkernel/spatial.h b/nestkernel/spatial.h index 7ceceeeb6c..215cfdf548 100644 --- a/nestkernel/spatial.h +++ b/nestkernel/spatial.h @@ -53,14 +53,14 @@ class LayerMetadata : public NodeCollectionMetadata { public: LayerMetadata( AbstractLayerPTR ); - ~LayerMetadata() + ~LayerMetadata() override { } - void set_status( const DictionaryDatum&, bool ) {}; + void set_status( const DictionaryDatum&, bool ) override {}; void - get_status( DictionaryDatum& d ) const + get_status( DictionaryDatum& d ) const override { layer_->get_status( d ); } @@ -74,25 +74,25 @@ class LayerMetadata : public NodeCollectionMetadata // Using string as enum would make stuff more complicated std::string - get_type() const + get_type() const override { return "spatial"; } void - set_first_node_id( index node_id ) + set_first_node_id( index node_id ) override { first_node_id_ = node_id; } index - get_first_node_id() const + get_first_node_id() const override { return first_node_id_; } bool - operator==( const NodeCollectionMetadataPTR rhs ) const + operator==( const NodeCollectionMetadataPTR rhs ) const override { const auto rhs_layer_metadata = dynamic_cast< LayerMetadata* >( rhs.get() ); if ( rhs_layer_metadata == nullptr ) diff --git a/nestkernel/structural_plasticity_node.h b/nestkernel/structural_plasticity_node.h index c90f6ef994..7130fbcc91 100644 --- a/nestkernel/structural_plasticity_node.h +++ b/nestkernel/structural_plasticity_node.h @@ -64,7 +64,7 @@ class StructuralPlasticityNode : public Node * \fn double get_Ca_minus() * return the current value of Ca_minus */ - double get_Ca_minus() const; + double get_Ca_minus() const override; /** * \fn double get_synaptic_elements(Name n) @@ -73,50 +73,50 @@ class StructuralPlasticityNode : public Node * actual vacant and connected elements is an integer truncated from this * value */ - double get_synaptic_elements( Name n ) const; + double get_synaptic_elements( Name n ) const override; /** * \fn int get_synaptic_elements_vacant(Name n) * Get the number of synaptic elements of type n which are available * for new synapse creation */ - int get_synaptic_elements_vacant( Name n ) const; + int get_synaptic_elements_vacant( Name n ) const override; /** * \fn int get_synaptic_elements_connected(Name n) * get the number of synaptic element of type n which are currently * connected */ - int get_synaptic_elements_connected( Name n ) const; + int get_synaptic_elements_connected( Name n ) const override; /** * \fn std::map get_synaptic_elements() * get the number of all synaptic elements for the current Node */ - std::map< Name, double > get_synaptic_elements() const; + std::map< Name, double > get_synaptic_elements() const override; /** * \fn void update_synaptic_elements() * Change the number of synaptic elements in the node depending on the * dynamics described by the corresponding growth curve */ - void update_synaptic_elements( double t ); + void update_synaptic_elements( double t ) override; /** * \fn void decay_synaptic_elements_vacant() * Delete a certain portion of the vacant synaptic elements which are not * in use */ - void decay_synaptic_elements_vacant(); + void decay_synaptic_elements_vacant() override; /** * \fn void connect_synaptic_element() * Change the number of connected synaptic elements by n */ - void connect_synaptic_element( Name name, int n ); + void connect_synaptic_element( Name name, int n ) override; - void get_status( DictionaryDatum& d ) const; - void set_status( const DictionaryDatum& d ); + void get_status( DictionaryDatum& d ) const override; + void set_status( const DictionaryDatum& d ) override; /** * retrieve the current value of tau_Ca which defines the exponential decay diff --git a/nestkernel/synaptic_element.cpp b/nestkernel/synaptic_element.cpp index 2c4d97d770..90e4162752 100644 --- a/nestkernel/synaptic_element.cpp +++ b/nestkernel/synaptic_element.cpp @@ -61,7 +61,7 @@ nest::SynapticElement::SynapticElement( const SynapticElement& se ) , tau_vacant_( se.tau_vacant_ ) { growth_curve_ = kernel().sp_manager.new_growth_curve( se.growth_curve_->get_name() ); - assert( growth_curve_ != 0 ); + assert( growth_curve_ != nullptr ); DictionaryDatum nc_parameters = DictionaryDatum( new Dictionary ); se.get( nc_parameters ); growth_curve_->set( nc_parameters ); diff --git a/nestkernel/target_identifier.h b/nestkernel/target_identifier.h index b06d65c2cf..f0152958d0 100644 --- a/nestkernel/target_identifier.h +++ b/nestkernel/target_identifier.h @@ -49,7 +49,7 @@ class TargetIdentifierPtrRport public: TargetIdentifierPtrRport() - : target_( 0 ) + : target_( nullptr ) , rport_( 0 ) { } @@ -63,7 +63,7 @@ class TargetIdentifierPtrRport get_status( DictionaryDatum& d ) const { // Do nothing if called on synapse prototype - if ( target_ != 0 ) + if ( target_ != nullptr ) { def< long >( d, names::rport, rport_ ); def< long >( d, names::target, target_->get_node_id() ); diff --git a/nestkernel/target_table_devices.cpp b/nestkernel/target_table_devices.cpp index 5035ce8380..8687cb8736 100644 --- a/nestkernel/target_table_devices.cpp +++ b/nestkernel/target_table_devices.cpp @@ -94,12 +94,12 @@ nest::TargetTableDevices::resize_to_number_of_synapse_types() for ( index lid = 0; lid < target_to_devices_[ tid ].size(); ++lid ) { // make sure this device has support for all synapse types - target_to_devices_[ tid ][ lid ].resize( kernel().model_manager.get_num_connection_models(), NULL ); + target_to_devices_[ tid ][ lid ].resize( kernel().model_manager.get_num_connection_models(), nullptr ); } for ( index ldid = 0; ldid < target_from_devices_[ tid ].size(); ++ldid ) { // make sure this device has support for all synapse types - target_from_devices_[ tid ][ ldid ].resize( kernel().model_manager.get_num_connection_models(), NULL ); + target_from_devices_[ tid ][ ldid ].resize( kernel().model_manager.get_num_connection_models(), nullptr ); } } // end omp parallel } @@ -142,7 +142,7 @@ nest::TargetTableDevices::get_connections_to_device_for_lid_( const index lid, { const index source_node_id = kernel().vp_manager.lid_to_node_id( lid ); // not the valid connector - if ( source_node_id > 0 and target_to_devices_[ tid ][ lid ][ syn_id ] != NULL ) + if ( source_node_id > 0 and target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) { target_to_devices_[ tid ][ lid ][ syn_id ]->get_all_connections( source_node_id, requested_target_node_id, tid, synapse_label, conns ); @@ -171,7 +171,7 @@ nest::TargetTableDevices::get_connections_from_devices_( const index requested_s if ( target_from_devices_[ tid ][ ldid ].size() > 0 ) { // not the valid connector - if ( target_from_devices_[ tid ][ ldid ][ syn_id ] != NULL ) + if ( target_from_devices_[ tid ][ ldid ][ syn_id ] != nullptr ) { target_from_devices_[ tid ][ ldid ][ syn_id ]->get_all_connections( source_node_id, requested_target_node_id, tid, synapse_label, conns ); diff --git a/nestkernel/target_table_devices_impl.h b/nestkernel/target_table_devices_impl.h index e75453e885..c7624637ea 100644 --- a/nestkernel/target_table_devices_impl.h +++ b/nestkernel/target_table_devices_impl.h @@ -100,7 +100,7 @@ nest::TargetTableDevices::send_to_device( const thread tid, const std::vector< synindex >& supported_syn_ids = e.get_supported_syn_ids(); for ( std::vector< synindex >::const_iterator cit = supported_syn_ids.begin(); cit != supported_syn_ids.end(); ++cit ) { - if ( target_to_devices_[ tid ][ lid ][ *cit ] != NULL ) + if ( target_to_devices_[ tid ][ lid ][ *cit ] != nullptr ) { target_to_devices_[ tid ][ lid ][ *cit ]->send_to_all( tid, cm, e ); } @@ -115,7 +115,7 @@ nest::TargetTableDevices::get_synapse_status_to_device( const thread tid, const index lcid ) const { const index lid = kernel().vp_manager.node_id_to_lid( source_node_id ); - if ( target_to_devices_[ tid ][ lid ][ syn_id ] != NULL ) + if ( target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) { target_to_devices_[ tid ][ lid ][ syn_id ]->get_synapse_status( tid, lcid, dict ); } @@ -130,7 +130,7 @@ nest::TargetTableDevices::set_synapse_status_to_device( const thread tid, const index lcid ) { const index lid = kernel().vp_manager.node_id_to_lid( source_node_id ); - if ( target_to_devices_[ tid ][ lid ][ syn_id ] != NULL ) + if ( target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) { target_to_devices_[ tid ][ lid ][ syn_id ]->set_synapse_status( lcid, dict, cm ); } diff --git a/nestkernel/urbanczik_archiving_node.h b/nestkernel/urbanczik_archiving_node.h index be85f42905..b858ed80f3 100644 --- a/nestkernel/urbanczik_archiving_node.h +++ b/nestkernel/urbanczik_archiving_node.h @@ -62,7 +62,7 @@ class UrbanczikArchivingNode : public ArchivingNode UrbanczikArchivingNode( const UrbanczikArchivingNode& ); bool - supports_urbanczik_archiving() const + supports_urbanczik_archiving() const override { return true; } @@ -78,37 +78,37 @@ class UrbanczikArchivingNode : public ArchivingNode double t2, std::deque< histentry_extended >::iterator* start, std::deque< histentry_extended >::iterator* finish, - int comp ); + int comp ) override; /** * \fn double get_C_m( int comp ) * Returns membrane capacitance */ - double get_C_m( int comp ); + double get_C_m( int comp ) override; /** * \fn double get_g_L( int comp ) * Returns leak conductance g_L */ - double get_g_L( int comp ); + double get_g_L( int comp ) override; /** * \fn double get_tau_L( int comp ) * Returns time constant tau_L */ - double get_tau_L( int comp ); + double get_tau_L( int comp ) override; /** * \fn double get_tau_s( int comp ) * Returns time constant tau_syn_ex */ - double get_tau_syn_ex( int comp ); + double get_tau_syn_ex( int comp ) override; /** * \fn double get_tau_syn_in( int comp ) * Returns time constant tau_syn_in */ - double get_tau_syn_in( int comp ); + double get_tau_syn_in( int comp ) override; protected: /** @@ -119,8 +119,8 @@ class UrbanczikArchivingNode : public ArchivingNode urbanczik_parameters* urbanczik_params; - void get_status( DictionaryDatum& d ) const; - void set_status( const DictionaryDatum& d ); + void get_status( DictionaryDatum& d ) const override; + void set_status( const DictionaryDatum& d ) override; private: std::deque< histentry_extended > urbanczik_history_[ urbanczik_parameters::NCOMP - 1 ]; diff --git a/nestkernel/vp_manager.h b/nestkernel/vp_manager.h index 381e8d767d..0265c81381 100644 --- a/nestkernel/vp_manager.h +++ b/nestkernel/vp_manager.h @@ -52,7 +52,7 @@ class VPManager : public ManagerInterface { public: VPManager(); - ~VPManager() + ~VPManager() override { } diff --git a/pynest/nest/versionchecker.py b/pynest/nest/versionchecker.py new file mode 100644 index 0000000000..3bb35f14b9 --- /dev/null +++ b/pynest/nest/versionchecker.py @@ -0,0 +1,33 @@ +# -*- coding: utf-8 -*- +# +# versionchecker.py +# +# 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 . + + +""" +Check that the Python compiletime and runtime versions match. + +""" + +v_major_mismatch = sys.version_info.major != 3 +v_minor_mismatch = sys.version_info.minor != 10 +if v_major_mismatch or v_minor_mismatch: + msg = ("Python runtime version does not match 'nest' compiletime version. " + + "Please use Python 3.10.") + raise Exception(msg) diff --git a/sli/allocator.cpp b/sli/allocator.cpp index 554039fbfd..554bb9411e 100644 --- a/sli/allocator.cpp +++ b/sli/allocator.cpp @@ -30,8 +30,8 @@ sli::pool::pool() , instantiations( 0 ) , total( 0 ) , capacity( 0 ) - , chunks( 0 ) - , head( 0 ) + , chunks( nullptr ) + , head( nullptr ) , initialized_( false ) { } @@ -44,8 +44,8 @@ sli::pool::pool( const sli::pool& p ) , instantiations( 0 ) , total( 0 ) , capacity( 0 ) - , chunks( 0 ) - , head( 0 ) + , chunks( nullptr ) + , head( nullptr ) , initialized_( false ) { } @@ -59,8 +59,8 @@ sli::pool::pool( size_t n, size_t initial, size_t growth ) , instantiations( 0 ) , total( 0 ) , capacity( 0 ) - , chunks( 0 ) - , head( 0 ) + , chunks( nullptr ) + , head( nullptr ) , initialized_( true ) { } @@ -79,8 +79,8 @@ sli::pool::init( size_t n, size_t initial, size_t growth ) instantiations = 0; total = 0; capacity = 0; - chunks = 0; - head = 0; + chunks = nullptr; + head = nullptr; } sli::pool::~pool() @@ -108,8 +108,8 @@ sli::pool::operator=( const sli::pool& p ) el_size = p.el_size; instantiations = 0; total = 0; - chunks = 0; - head = 0; + chunks = nullptr; + head = nullptr; initialized_ = false; return *this; @@ -129,12 +129,12 @@ sli::pool::grow( size_t nelements ) { reinterpret_cast< link* >( p )->next = reinterpret_cast< link* >( p + el_size ); } - reinterpret_cast< link* >( last )->next = NULL; + reinterpret_cast< link* >( last )->next = nullptr; head = reinterpret_cast< link* >( start ); } void -sli::pool::grow( void ) +sli::pool::grow( ) { grow( block_size ); block_size *= growth_factor; diff --git a/sli/allocator.h b/sli/allocator.h index b249fd8804..041322b027 100644 --- a/sli/allocator.h +++ b/sli/allocator.h @@ -70,9 +70,9 @@ class pool chunk* next; char* mem; - chunk( size_t s ) + explicit chunk( size_t s ) : csize( s ) - , next( 0 ) + , next( nullptr ) , mem( new char[ csize ] ) { } @@ -80,11 +80,11 @@ class pool ~chunk() { delete[] mem; - mem = NULL; + mem = nullptr; } size_t - size( void ) + size( ) const { return csize; } @@ -117,7 +117,7 @@ class pool pool( const pool& ); pool& operator=( const pool& ); - pool( size_t n, size_t initial = 100, size_t growth = 1 ); + explicit pool( size_t n, size_t initial = 100, size_t growth = 1 ); void init( size_t n, size_t initial = 100, size_t growth = 1 ); ~pool(); //!< deallocate ALL memory @@ -133,15 +133,15 @@ class pool void reserve_additional( size_t n ); size_t - available( void ) const + available( ) const { return total - instantiations; } - inline void* alloc( void ); //!< allocate one element + inline void* alloc( ); //!< allocate one element inline void free( void* p ); //!< put element back into the pool size_t - size_of( void ) const + size_of( ) const { return el_size; } @@ -152,10 +152,10 @@ class pool }; inline void* -pool::alloc( void ) +pool::alloc( ) { - if ( head == 0 ) + if ( head == nullptr ) { grow( block_size ); block_size *= growth_factor; diff --git a/sli/booldatum.cc b/sli/booldatum.cc index baa6d2e37f..690c881f91 100644 --- a/sli/booldatum.cc +++ b/sli/booldatum.cc @@ -77,7 +77,7 @@ BoolDatum::operator new( size_t size ) void BoolDatum::operator delete( void* p, size_t size ) { - if ( p == NULL ) + if ( p == nullptr ) { return; } diff --git a/sli/booldatum.h b/sli/booldatum.h index 665ce451d8..c19f6d35fd 100644 --- a/sli/booldatum.h +++ b/sli/booldatum.h @@ -44,7 +44,7 @@ class BoolDatum : public GenericDatum< bool, &SLIInterpreter::Booltype > private: Datum* - clone( void ) const + clone( void ) const override { return new BoolDatum( *this ); } @@ -76,9 +76,9 @@ class BoolDatum : public GenericDatum< bool, &SLIInterpreter::Booltype > operator std::string() const; - void input_form( std::ostream& ) const; - void print( std::ostream& ) const; - void pprint( std::ostream& ) const; + void input_form( std::ostream& ) const override; + void print( std::ostream& ) const override; + void pprint( std::ostream& ) const override; static void* operator new( size_t size ); diff --git a/sli/datum.h b/sli/datum.h index c584ca91ba..197aa5d8d3 100644 --- a/sli/datum.h +++ b/sli/datum.h @@ -40,7 +40,7 @@ class Datum * Virtual copy constructor. * Use this function to lazily copy a datum. */ - virtual Datum* clone( void ) const = 0; + virtual Datum* clone( ) const = 0; /** @@ -67,8 +67,8 @@ class Datum Datum() - : type( NULL ) - , action( NULL ) + : type( nullptr ) + , action( nullptr ) , reference_count_( 1 ) , executable_( true ) { @@ -169,7 +169,7 @@ class Datum virtual void info( std::ostream& ) const; const Name& - gettypename( void ) const + gettypename( ) const { return type->gettypename(); } @@ -192,7 +192,7 @@ template < SLIType* slt > class TypedDatum : public Datum { public: - TypedDatum( void ) + TypedDatum( ) : Datum( slt ) { } diff --git a/sli/dict.h b/sli/dict.h index 836618af6c..f7c6507b98 100644 --- a/sli/dict.h +++ b/sli/dict.h @@ -132,7 +132,7 @@ class Dictionary : private TokenMap Token& operator[]( const char* ); bool - empty( void ) const + empty( ) const { return TokenMap::empty(); } @@ -212,7 +212,7 @@ class Dictionary : private TokenMap /** * */ - void initialize_property_array( Name propname ); + // void initialize_property_array( Name propname ); /** * This function is called when a dictionary is pushed to the dictionary diff --git a/sli/dictstack.cc b/sli/dictstack.cc index a923609321..012cf5eddb 100644 --- a/sli/dictstack.cc +++ b/sli/dictstack.cc @@ -93,7 +93,7 @@ DictionaryStack::basedef_move( const Name& n, Token& t ) void -DictionaryStack::pop( void ) +DictionaryStack::pop( ) { // // remove top dictionary from stack @@ -108,7 +108,7 @@ DictionaryStack::pop( void ) } void -DictionaryStack::clear( void ) +DictionaryStack::clear( ) { d.erase( d.begin(), d.end() ); #ifdef DICTSTACK_CACHE @@ -156,7 +156,7 @@ void DictionaryStack::push( Token& d ) { DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( d.datum() ); - assert( dd != NULL ); + assert( dd != nullptr ); push( *dd ); } @@ -185,7 +185,7 @@ DictionaryStack::set_basedict() } size_t -DictionaryStack::size( void ) const +DictionaryStack::size( ) const { // // return number of dictionaries on stack diff --git a/sli/dictstack.h b/sli/dictstack.h index 49812e0262..7fb75c7282 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -336,7 +336,7 @@ class DictionaryStack */ void basedef_move( const Name& n, Token& t ); - bool where( const Name&, Token& ); + // bool where( const Name&, Token& ); void pop( void ); diff --git a/sli/dictutils.cc b/sli/dictutils.cc index 7ebd0a2c0b..6a30c93156 100644 --- a/sli/dictutils.cc +++ b/sli/dictutils.cc @@ -61,7 +61,7 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< double > Token t = d->lookup2( propname ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add { @@ -79,7 +79,7 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< long >& Token t = d->lookup2( propname ); IntVectorDatum* arrd = dynamic_cast< IntVectorDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add { @@ -96,7 +96,7 @@ accumulate_property( DictionaryDatum& d, Name propname, const std::vector< doubl Token t = d->lookup2( propname ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); if ( ( *arrd )->empty() ) // first data, copy { diff --git a/sli/dictutils.h b/sli/dictutils.h index a4a5198c68..bc355b5556 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -90,7 +90,7 @@ get_double_in_range( const DictionaryDatum& d, Name const n, double min, double // token. const Token& t = d->lookup2( n ); DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); - double x = 0.0; + double x; if ( dd != 0 ) { @@ -154,7 +154,7 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i // token. const Token& t = d->lookup2( n ); DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); - long x = 0; + long x; if ( dd != 0 ) { diff --git a/sli/fdstream.cc b/sli/fdstream.cc index 6db90ff410..849ced82a0 100644 --- a/sli/fdstream.cc +++ b/sli/fdstream.cc @@ -35,7 +35,7 @@ fdbuf::open( const char* s, std::ios_base::openmode mode ) if ( is_open() ) { // std::cerr<<"Is already open!"<close() == NULL ) + if ( rdbuf()->close() == nullptr ) { setstate( failbit ); } @@ -139,7 +139,7 @@ ofdstream::close() void ifdstream::close() { - if ( rdbuf()->close() == NULL ) + if ( rdbuf()->close() == nullptr ) { setstate( failbit ); } @@ -148,7 +148,7 @@ ifdstream::close() void fdstream::close() { - if ( rdbuf()->close() == NULL ) + if ( rdbuf()->close() == nullptr ) { setstate( failbit ); } diff --git a/sli/fdstream.h b/sli/fdstream.h index 09c6e24b0c..3f3f4ad63f 100644 --- a/sli/fdstream.h +++ b/sli/fdstream.h @@ -92,7 +92,7 @@ class fdbuf : public std::streambuf setp( m_outbuf, m_outbuf + s_bufsiz ); } - ~fdbuf() + ~fdbuf() override { // sync(); close(); @@ -120,7 +120,7 @@ class fdbuf : public std::streambuf protected: int_type - underflow() + underflow() override { if ( gptr() == egptr() ) { @@ -135,7 +135,7 @@ class fdbuf : public std::streambuf } int_type - overflow( int_type c ) + overflow( int_type c ) override { if ( sync() == -1 ) { @@ -153,7 +153,7 @@ class fdbuf : public std::streambuf } int - sync() + sync() override { std::streamsize size = pptr() - pbase(); if ( size > 0 && ::write( m_fd, m_outbuf, size ) != size ) @@ -185,7 +185,7 @@ class ofdstream : public std::ostream */ ofdstream() - : std::ostream( 0 ) + : std::ostream( nullptr ) , sb() { std::ostream::rdbuf( &sb ); @@ -193,7 +193,7 @@ class ofdstream : public std::ostream } explicit ofdstream( const char* s, std::ios_base::openmode mode = std::ios_base::out ) - : std::ostream( 0 ) + : std::ostream( nullptr ) , sb() { std::ostream::rdbuf( &sb ); @@ -203,7 +203,7 @@ class ofdstream : public std::ostream } explicit ofdstream( int fd ) - : std::ostream( 0 ) + : std::ostream( nullptr ) , sb( fd ) { std::ostream::rdbuf( &sb ); @@ -226,7 +226,7 @@ class ofdstream : public std::ostream void open( const char* s, std::ios_base::openmode mode = std::ios_base::out ) { - if ( rdbuf()->open( s, mode | std::ios_base::out ) == NULL ) + if ( rdbuf()->open( s, mode | std::ios_base::out ) == nullptr ) { setstate( failbit ); } @@ -242,7 +242,7 @@ class ifdstream : public std::istream { public: ifdstream() - : std::istream( 0 ) + : std::istream( nullptr ) , sb() { std::istream::rdbuf( &sb ); @@ -250,7 +250,7 @@ class ifdstream : public std::istream } explicit ifdstream( const char* s, std::ios_base::openmode mode = std::ios_base::in ) - : std::istream( 0 ) + : std::istream( nullptr ) , sb() { std::istream::rdbuf( &sb ); @@ -259,7 +259,7 @@ class ifdstream : public std::istream } explicit ifdstream( int fd ) - : std::istream( 0 ) + : std::istream( nullptr ) , sb( fd ) { std::istream::rdbuf( &sb ); @@ -283,7 +283,7 @@ class ifdstream : public std::istream void open( const char* s, std::ios_base::openmode mode = std::ios_base::in ) { - if ( rdbuf()->open( s, mode | std::ios_base::in ) == NULL ) + if ( rdbuf()->open( s, mode | std::ios_base::in ) == nullptr ) { setstate( failbit ); } @@ -299,7 +299,7 @@ class fdstream : public std::iostream { public: fdstream() - : std::iostream( 0 ) + : std::iostream( nullptr ) , sb() // See Constructor comment above. { std::iostream::rdbuf( &sb ); @@ -307,7 +307,7 @@ class fdstream : public std::iostream } explicit fdstream( const char* s, std::ios_base::openmode mode ) - : std::iostream( 0 ) + : std::iostream( nullptr ) , sb() // See Constructor comment above. { std::iostream::rdbuf( &sb ); @@ -317,7 +317,7 @@ class fdstream : public std::iostream explicit fdstream( int fd ) : // See Constructor comment above. - std::iostream( 0 ) + std::iostream( nullptr ) , sb( fd ) { std::iostream::rdbuf( &sb ); @@ -341,7 +341,7 @@ class fdstream : public std::iostream void open( const char* s, std::ios_base::openmode mode ) { - if ( rdbuf()->open( s, mode ) == NULL ) + if ( rdbuf()->open( s, mode ) == nullptr ) { setstate( failbit ); } diff --git a/sli/filesystem.cc b/sli/filesystem.cc index bfb8c28c7e..b63426295b 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -60,13 +60,13 @@ FilesystemModule::init( SLIInterpreter* i ) const std::string -FilesystemModule::name( void ) const +FilesystemModule::name( ) const { return std::string( "Filesystem access" ); } const std::string -FilesystemModule::commandstring( void ) const +FilesystemModule::commandstring( ) const { return std::string( "(filesystem.sli) run" ); } @@ -76,16 +76,16 @@ void FilesystemModule::FileNamesFunction::execute( SLIInterpreter* i ) const { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); DIR* TheDirectory = opendir( sd->c_str() ); - if ( TheDirectory != NULL ) + if ( TheDirectory != nullptr ) { ArrayDatum* a = new ArrayDatum(); i->EStack.pop(); i->OStack.pop(); dirent* TheEntry; - while ( ( TheEntry = readdir( TheDirectory ) ) != NULL ) + while ( ( TheEntry = readdir( TheDirectory ) ) != nullptr ) { Token string_token( new StringDatum( TheEntry->d_name ) ); a->push_back_move( string_token ); @@ -104,7 +104,7 @@ FilesystemModule::SetDirectoryFunction::execute( SLIInterpreter* i ) const // string -> boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); int s = chdir( sd->c_str() ); i->OStack.pop(); if ( not s ) @@ -114,7 +114,7 @@ FilesystemModule::SetDirectoryFunction::execute( SLIInterpreter* i ) const else { i->OStack.push( i->baselookup( i->false_name ) ); - }; + } i->EStack.pop(); } @@ -139,7 +139,7 @@ FilesystemModule::DirectoryFunction::execute( SLIInterpreter* i ) const int size = SIZE; char* path_buffer = new char[ size ]; - while ( getcwd( path_buffer, size - 1 ) == NULL ) + while ( getcwd( path_buffer, size - 1 ) == nullptr ) { // try again with a bigger buffer! if ( errno != ERANGE ) { @@ -148,7 +148,7 @@ FilesystemModule::DirectoryFunction::execute( SLIInterpreter* i ) const delete[] path_buffer; size += SIZE; path_buffer = new char[ size ]; - assert( path_buffer != NULL ); + assert( path_buffer != nullptr ); } Token sd( new StringDatum( path_buffer ) ); delete[]( path_buffer ); @@ -162,8 +162,8 @@ FilesystemModule::MoveFileFunction::execute( SLIInterpreter* i ) const { StringDatum* src = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* dst = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( src != NULL ); - assert( dst != NULL ); + assert( src != nullptr ); + assert( dst != nullptr ); int s = link( src->c_str(), dst->c_str() ); if ( not s ) { @@ -192,8 +192,8 @@ FilesystemModule::CopyFileFunction::execute( SLIInterpreter* i ) const { StringDatum* src = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* dst = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( src != NULL ); - assert( dst != NULL ); + assert( src != nullptr ); + assert( dst != nullptr ); std::ofstream deststream( dst->c_str() ); if ( not deststream ) @@ -232,7 +232,7 @@ FilesystemModule::DeleteFileFunction::execute( SLIInterpreter* i ) const // string -> boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); int s = unlink( sd->c_str() ); i->OStack.pop(); if ( not s ) @@ -251,7 +251,7 @@ FilesystemModule::MakeDirectoryFunction::execute( SLIInterpreter* i ) const // string -> Boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); int s = mkdir( sd->c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP ); i->OStack.pop(); if ( not s ) @@ -270,7 +270,7 @@ FilesystemModule::RemoveDirectoryFunction::execute( SLIInterpreter* i ) const // string -> Boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); int s = rmdir( sd->c_str() ); i->OStack.pop(); if ( not s ) @@ -306,7 +306,7 @@ void FilesystemModule::TmpNamFunction::execute( SLIInterpreter* i ) const { std::lock_guard< std::mutex > lock( mtx ); - static unsigned int seed = std::time( 0 ); + static unsigned int seed = std::time( nullptr ); char* env = getenv( "TMPDIR" ); std::string tmpdir( "/tmp" ); if ( env ) diff --git a/sli/filesystem.h b/sli/filesystem.h index fb3c9e4f16..08a8dc8c3a 100644 --- a/sli/filesystem.h +++ b/sli/filesystem.h @@ -38,49 +38,49 @@ class FilesystemModule : public SLIModule class FileNamesFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetDirectoryFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DirectoryFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class MoveFileFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CopyFileFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DeleteFileFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class MakeDirectoryFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RemoveDirectoryFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class TmpNamFunction : public SLIFunction @@ -89,7 +89,7 @@ class FilesystemModule : public SLIModule TmpNamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CompareFilesFunction : public SLIFunction @@ -98,7 +98,7 @@ class FilesystemModule : public SLIModule CompareFilesFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; public: @@ -113,12 +113,12 @@ class FilesystemModule : public SLIModule TmpNamFunction tmpnamfunction; CompareFilesFunction comparefilesfunction; - FilesystemModule( void ) {}; - ~FilesystemModule() {}; + FilesystemModule( ) {}; + ~FilesystemModule() override {}; - void init( SLIInterpreter* ); - const std::string name( void ) const; - const std::string commandstring( void ) const; + void init( SLIInterpreter* ) override; + const std::string name( ) const override; + const std::string commandstring( ) const override; }; #endif diff --git a/sli/genericdatum.h b/sli/genericdatum.h index 7688c0fea8..43620e97e2 100644 --- a/sli/genericdatum.h +++ b/sli/genericdatum.h @@ -38,7 +38,7 @@ class GenericDatum : public TypedDatum< slt > { virtual Datum* - clone( void ) const + clone( ) const { return new GenericDatum< D, slt >( *this ); } @@ -71,13 +71,13 @@ class GenericDatum : public TypedDatum< slt > } const D& - get( void ) const + get( ) const { return d; } D& - get( void ) + get( ) { return d; } diff --git a/sli/gnureadline.h b/sli/gnureadline.h index a2c651a289..c85a90dae7 100644 --- a/sli/gnureadline.h +++ b/sli/gnureadline.h @@ -38,26 +38,26 @@ class GNUReadline : public SLIModule GNUReadline() { } - ~GNUReadline(); + ~GNUReadline() override; const std::string - name( void ) const + name( void ) const override { return "GNUReadline"; } - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; class GNUReadlineFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GNUAddhistoryFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; GNUReadlineFunction gnureadlinefunction; diff --git a/sli/interpret.cc b/sli/interpret.cc index f04b3cd05e..1413157948 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -140,7 +140,7 @@ const IforallindexedstringFunction SLIInterpreter::iforallindexedstringfunction; const IforallstringFunction SLIInterpreter::iforallstringfunction; void -SLIInterpreter::inittypes( void ) +SLIInterpreter::inittypes( ) { Integertype.settypename( "integertype" ); Integertype.setdefaultaction( datatypefunction ); @@ -183,12 +183,12 @@ SLIInterpreter::inittypes( void ) } void -SLIInterpreter::initdictionaries( void ) +SLIInterpreter::initdictionaries( ) { - assert( DStack == NULL ); + assert( DStack == nullptr ); DStack = new DictionaryStack(); - assert( DStack != NULL ); + assert( DStack != nullptr ); errordict = new Dictionary(); DictionaryDatum sysdict( new Dictionary() ); @@ -204,7 +204,7 @@ SLIInterpreter::initdictionaries( void ) } void -SLIInterpreter::initbuiltins( void ) +SLIInterpreter::initbuiltins( ) { createcommand( ilookup_name, &SLIInterpreter::ilookupfunction ); @@ -224,7 +224,7 @@ SLIInterpreter::initbuiltins( void ) } void -SLIInterpreter::initexternals( void ) +SLIInterpreter::initexternals( ) { init_slidict( this ); init_slicontrol( this ); diff --git a/sli/interpret.h b/sli/interpret.h index faa5c6e30d..059b852617 100644 --- a/sli/interpret.h +++ b/sli/interpret.h @@ -86,10 +86,10 @@ class SLIInterpreter int verbositylevel; - void inittypes( void ); - void initdictionaries( void ); - void initbuiltins( void ); - void initexternals( void ); + void inittypes( ); + void initdictionaries( ); + void initbuiltins( ); + void initexternals( ); public: unsigned long code_accessed; // for code coverage analysis. @@ -251,7 +251,7 @@ class SLIInterpreter TokenStack EStack; // public member functions: - SLIInterpreter( void ); + SLIInterpreter( ); ~SLIInterpreter(); //! Initialise the interpreter by reading in the startup files. @@ -340,7 +340,7 @@ class SLIInterpreter void basedef_move( const Name& n, Token& t ); void setcycleguard( Index ); - void removecycleguard( void ); + void removecycleguard( ); /** @@ -752,7 +752,7 @@ class SLIInterpreter * @see raiseerror(const char*), raiseerror(Name), * raiseerror(Name,Name) */ - void raiseagain( void ); + void raiseagain( ); /** TO BE DOCUMENTED. * @todo Document this function. @@ -798,7 +798,7 @@ class SLIInterpreter * error(), fatal() * @ingroup SLIMessaging */ - int verbosity( void ) const; + int verbosity( ) const; /** Display a message. * @param level The error level that shall be associated with the @@ -845,17 +845,17 @@ class SLIInterpreter void terminate( int returnvalue = -1 ); //******************************************************* - Name getcurrentname( void ) const; + Name getcurrentname( ) const; unsigned long - cycles( void ) const + cycles( ) const { return cycle_count; } template < class T > - void addmodule( void ); + void addmodule( ); void addmodule( SLIModule* ); /* @@ -866,8 +866,8 @@ class SLIInterpreter */ void addlinkedusermodule( SLIModule* ); - FunctionDatum* Ilookup( void ) const; - FunctionDatum* Iiterate( void ) const; + FunctionDatum* Ilookup( ) const; + FunctionDatum* Iiterate( ) const; /** * Throw StackUnderflow exception if too few elements on stack. @@ -893,7 +893,7 @@ addmodule( SLIInterpreter& i ) template < class T > void -SLIInterpreter::addmodule( void ) +SLIInterpreter::addmodule( ) { SLIModule* m = new T(); diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index e750c3fe9c..167da29948 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -43,7 +43,7 @@ template < class D, SLIType* slt > class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > { Datum* - clone( void ) const + clone( ) const { return new lockPTRDatum< D, slt >( *this ); } @@ -114,7 +114,7 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > implementation is defined. */ private: - bool operator==( lockPTR< D >& ); + // bool operator==( lockPTR< D >& ); }; /* equals(const Datum* datum) diff --git a/sli/name.cc b/sli/name.cc index e5b2c1e66a..a82b64ed06 100644 --- a/sli/name.cc +++ b/sli/name.cc @@ -69,7 +69,7 @@ Name::print_handle( std::ostream& o ) const const std::string& -Name::toString( void ) const +Name::toString( ) const { return handleTableInstance_()[ handle_ ]; } diff --git a/sli/name.h b/sli/name.h index 52655e7077..a77bba761a 100644 --- a/sli/name.h +++ b/sli/name.h @@ -99,7 +99,7 @@ class Name bool operator!=( const Name& n ) const { - return not( handle_ == n.handle_ ); + return handle_ != n.handle_; } /** diff --git a/sli/namedatum.h b/sli/namedatum.h index 5e80d3c225..b404d04d30 100644 --- a/sli/namedatum.h +++ b/sli/namedatum.h @@ -67,13 +67,13 @@ sli::pool AggregateDatum< Name, &SLIInterpreter::Literaltype >::memory; class NameDatum : public AggregateDatum< Name, &SLIInterpreter::Nametype > { Datum* - clone( void ) const + clone( ) const override { return new NameDatum( *this ); } Datum* - get_ptr() + get_ptr() override { Datum::addReference(); return this; @@ -89,7 +89,7 @@ class NameDatum : public AggregateDatum< Name, &SLIInterpreter::Nametype > : AggregateDatum< Name, &SLIInterpreter::Nametype >( n ) { } - ~NameDatum() + ~NameDatum() override { set_executable(); } @@ -98,13 +98,13 @@ class NameDatum : public AggregateDatum< Name, &SLIInterpreter::Nametype > class LiteralDatum : public AggregateDatum< Name, &SLIInterpreter::Literaltype > { Datum* - clone( void ) const + clone( ) const override { return new LiteralDatum( *this ); } Datum* - get_ptr() + get_ptr() override { Datum::addReference(); return this; @@ -121,10 +121,10 @@ class LiteralDatum : public AggregateDatum< Name, &SLIInterpreter::Literaltype > { set_executable(); } - ~LiteralDatum() + ~LiteralDatum() override { } - void pprint( std::ostream& ) const; + void pprint( std::ostream& ) const override; }; #endif diff --git a/sli/numericdatum.h b/sli/numericdatum.h index 792ccaffe4..4950cb8760 100644 --- a/sli/numericdatum.h +++ b/sli/numericdatum.h @@ -47,7 +47,7 @@ class NumericDatum : public GenericDatum< D, slt > private: Datum* - clone( void ) const + clone( ) const { return new NumericDatum< D, slt >( *this ); } @@ -100,7 +100,7 @@ class NumericDatum : public GenericDatum< D, slt > static void operator delete( void* p, size_t size ) { - if ( p == NULL ) + if ( p == nullptr ) { return; } diff --git a/sli/oosupport.cc b/sli/oosupport.cc index 63e00fc730..ff836e895e 100644 --- a/sli/oosupport.cc +++ b/sli/oosupport.cc @@ -38,13 +38,13 @@ OOSupportModule::init( SLIInterpreter* i ) } const std::string -OOSupportModule::commandstring( void ) const +OOSupportModule::commandstring( ) const { return std::string( "(oosupport.sli) run" ); } const std::string -OOSupportModule::name( void ) const +OOSupportModule::name( ) const { return std::string( "OOSupport" ); } @@ -55,13 +55,13 @@ OOSupportModule::CallMemberFunction::execute( SLIInterpreter* i ) const // call: dict key call -> unknown DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - assert( key != NULL ); + assert( key != nullptr ); Token value = ( *dict )->lookup( *key ); - if ( value.datum() != NULL ) + if ( value.datum() != nullptr ) { Token nt( new NameDatum( *key ) ); i->DStack->push( *dict ); diff --git a/sli/parser.cc b/sli/parser.cc index 8a0dce6a2a..f690d02c3a 100644 --- a/sli/parser.cc +++ b/sli/parser.cc @@ -56,26 +56,26 @@ Parser::init( std::istream& is ) } Parser::Parser( std::istream& is ) - : s( NULL ) + : s( nullptr ) , ParseStack( 128 ) { init( is ); - assert( s != NULL ); + assert( s != nullptr ); } -Parser::Parser( void ) - : s( NULL ) +Parser::Parser( ) + : s( nullptr ) , ParseStack( 128 ) { init( std::cin ); - assert( s != NULL ); + assert( s != nullptr ); } bool Parser::operator()( Token& t ) { - assert( s != NULL ); + assert( s != nullptr ); Token pt; @@ -158,13 +158,13 @@ Parser::operator()( Token& t ) if ( pt->isoftype( SLIInterpreter::Arraytype ) ) { ArrayDatum* pa = dynamic_cast< ArrayDatum* >( pt.datum() ); - assert( pa != NULL ); + assert( pa != nullptr ); pa->push_back( t ); } else // now it must be a procedure { LitprocedureDatum* pp = dynamic_cast< LitprocedureDatum* >( pt.datum() ); - assert( pp != NULL ); + assert( pp != nullptr ); pp->set_executable(); pp->push_back( t ); } diff --git a/sli/parser.h b/sli/parser.h index 73a7641021..5ffb0d4e43 100644 --- a/sli/parser.h +++ b/sli/parser.h @@ -59,7 +59,7 @@ class Parser void init( std::istream& ); public: - Parser( void ); + Parser( ); Parser( std::istream& ); bool operator()( Token& ); @@ -78,7 +78,7 @@ class Parser } Scanner const* - scan( void ) const + scan( ) const { return s; } @@ -86,7 +86,7 @@ class Parser void clear_context() { - if ( s != NULL ) + if ( s != nullptr ) { s->clear_context(); } diff --git a/sli/parserdatum.h b/sli/parserdatum.h index 4464359937..716dabf6a3 100644 --- a/sli/parserdatum.h +++ b/sli/parserdatum.h @@ -31,12 +31,12 @@ class ParserDatum : public AggregateDatum< Parser, &SLIInterpreter::Parsertype > { Datum* - clone( void ) const + clone( ) const { return new ParserDatum( *this ); } - ParserDatum( void ) + ParserDatum( ) { set_executable(); } diff --git a/sli/processes.cc b/sli/processes.cc index 9f0fffdcf2..82186d7c70 100644 --- a/sli/processes.cc +++ b/sli/processes.cc @@ -100,7 +100,7 @@ const std::string Processes::systemerror( SLIInterpreter* i ) { Token errordict_t( i->baselookup( i->errordict_name ) ); - assert( errordict_t.datum() != NULL ); + assert( errordict_t.datum() != nullptr ); DictionaryDatum errordict_d = *dynamic_cast< DictionaryDatum* >( errordict_t.datum() ); std::string ErrorMessage( std::strerror( errno ) ); @@ -121,7 +121,7 @@ Processes::fd( std::istream* s ) else { ifdstream* fs = dynamic_cast< ifdstream* >( s ); - assert( fs != NULL ); + assert( fs != nullptr ); return fs->rdbuf()->fd(); } } @@ -140,7 +140,7 @@ Processes::fd( std::ostream* s ) else { ofdstream* fs = dynamic_cast< ofdstream* >( s ); - assert( fs != NULL ); + assert( fs != nullptr ); return fs->rdbuf()->fd(); } } @@ -148,13 +148,13 @@ Processes::fd( std::ostream* s ) // end of definition of static variables and functions const std::string -Processes::name( void ) const +Processes::name( ) const { return std::string( "basic process management" ); // Return name of the module } const std::string -Processes::commandstring( void ) const +Processes::commandstring( ) const { return std::string( "(processes.sli) run" ); } @@ -196,7 +196,7 @@ Processes::init( SLIInterpreter* i ) // create variables "sys_errname" and "sys_errno" // and all needed errornumbers in errordict Token errordict_t( i->baselookup( i->errordict_name ) ); - assert( errordict_t.datum() != NULL ); + assert( errordict_t.datum() != nullptr ); DictionaryDatum errordict_d = *dynamic_cast< DictionaryDatum* >( errordict_t.datum() ); errordict_d->insert( sys_errname, new LiteralDatum( "" ) ); @@ -338,7 +338,7 @@ Processes::Sysexec_aFunction::execute( SLIInterpreter* i ) const // this is an array of tokens (to names) ArrayDatum* array = dynamic_cast< ArrayDatum* >( array_token.datum() ); - assert( array != NULL ); + assert( array != nullptr ); assert( array->size() > 0 ); // need at least the commandname @@ -355,13 +355,13 @@ Processes::Sysexec_aFunction::execute( SLIInterpreter* i ) const for ( unsigned int j = 0; j < array->size(); j++ ) // forall in array { StringDatum* nd = dynamic_cast< StringDatum* >( ( *array )[ j ].datum() ); - assert( nd != NULL ); + assert( nd != nullptr ); // StringDatum is derived from class string. argv[ j ] = const_cast< char* >( nd->c_str() ); } char* command = argv[ 0 ]; - argv[ array->size() ] = NULL; + argv[ array->size() ] = nullptr; int result = execvp( command, argv ); // int result = execvp(command, const_cast (argv) ); delete[] argv; @@ -383,10 +383,10 @@ Processes::WaitPIDFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IntegerDatum* pidin_d = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( pidin_d != NULL ); + assert( pidin_d != nullptr ); BoolDatum* nohangflag_d = dynamic_cast< BoolDatum* >( i->OStack.top().datum() ); - assert( nohangflag_d != NULL ); + assert( nohangflag_d != nullptr ); // call waitpid() int stat_value; @@ -455,10 +455,10 @@ Processes::KillFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IntegerDatum* pid_d = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( pid_d != NULL ); + assert( pid_d != nullptr ); IntegerDatum* signal_d = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( signal_d != NULL ); + assert( signal_d != nullptr ); // call kill() int result = kill( pid_d->get(), signal_d->get() ); @@ -510,9 +510,9 @@ Processes::Dup2_is_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); IstreamDatum* s_d2 = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != NULL ); + assert( s_d2 != nullptr ); // call dup2(); // int result = dup2( fd(s_d1->get()) , fd(s_d2->get()) );//using get() on a @@ -544,9 +544,9 @@ Processes::Dup2_os_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); OstreamDatum* s_d2 = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != NULL ); + assert( s_d2 != nullptr ); // call dup2(); // for comments on LockPTRs see Dup2_is_isFunction::execute @@ -572,9 +572,9 @@ Processes::Dup2_is_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); OstreamDatum* s_d2 = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != NULL ); + assert( s_d2 != nullptr ); // call dup2(); // int result = dup2( fd(s_d1->get()) , fd(s_d2->get()) );//using get() on a @@ -606,9 +606,9 @@ Processes::Dup2_os_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); IstreamDatum* s_d2 = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != NULL ); + assert( s_d2 != nullptr ); // call dup2(); // for comments on LockPTRs see Dup2_is_isFunction::execute @@ -633,7 +633,7 @@ Processes::AvailableFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( istreamdatum != 0 ); + assert( istreamdatum != nullptr ); assert( istreamdatum->valid() ); if ( not( **istreamdatum ).good() ) @@ -797,7 +797,7 @@ Processes::MkfifoFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: StringDatum* s_d = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s_d != NULL ); + assert( s_d != nullptr ); // call mkfifo(); mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; // Try to give all permissions, @@ -841,11 +841,11 @@ Processes::SetNonblockFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 2 ); // setNONBLOCK takes 2 arguments IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( istreamdatum != 0 ); + assert( istreamdatum != nullptr ); assert( istreamdatum->valid() ); BoolDatum* newflag_d = dynamic_cast< BoolDatum* >( i->OStack.top().datum() ); - assert( newflag_d != NULL ); + assert( newflag_d != nullptr ); // get filedescriptor: // istreamdatum is a pointer to a LockPTR @@ -907,7 +907,7 @@ Processes::Isatty_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); int fd = Processes::fd( **s_d1 ); // Get FileDescriptor @@ -932,7 +932,7 @@ Processes::Isatty_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s_d1 != NULL ); + assert( s_d1 != nullptr ); int fd = Processes::fd( **s_d1 ); // Get FileDescriptor diff --git a/sli/processes.h b/sli/processes.h index 68f33e2bec..e8fe99c1d7 100644 --- a/sli/processes.h +++ b/sli/processes.h @@ -140,7 +140,7 @@ class Processes : public SLIModule const Name EXDEV_name; // The constructor and destructor for our module object (-if we need them-): - Processes( void ) + Processes( ) : signaldict_name( "signaldict" ) , SIGABRT_name( "SIGABRT" ) , SIGALRM_name( "SIGALRM" ) @@ -207,17 +207,17 @@ class Processes : public SLIModule { } // Processes constructor - ~Processes( void ); // clean up dynmem for static variables... + ~Processes( ) override; // clean up dynmem for static variables... // The Module is registered by a call to this Function: - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; // This function will return the name of our module: - const std::string name( void ) const; + const std::string name( ) const override; // This function -may- return a string of SLI-commands to be executed for // initialization - const std::string commandstring( void ) const; + const std::string commandstring( ) const override; // --------------------------------------------------------------- @@ -230,72 +230,72 @@ class Processes : public SLIModule class ForkFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Sysexec_aFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class WaitPIDFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class KillFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class PipeFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Dup2_is_isFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Dup2_os_osFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Dup2_is_osFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Dup2_os_isFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class AvailableFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class GetPIDFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class GetPPIDFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class GetPGRPFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class MkfifoFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; #if defined __APPLE__ && defined HAVE_MACH_MACH_H @@ -308,22 +308,22 @@ class Processes : public SLIModule class SetNonblockFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class CtermidFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Isatty_isFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; class Isatty_osFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; // This is all we need. + void execute( SLIInterpreter* ) const override; // This is all we need. }; // Module contains -one- instantiation of each new function-class: diff --git a/sli/scanner.h b/sli/scanner.h index 67b5f36e83..77114c298b 100644 --- a/sli/scanner.h +++ b/sli/scanner.h @@ -163,7 +163,7 @@ class Scanner * Return input stream. */ std::istream* - GetSource( void ) + GetSource( ) { return in; } diff --git a/sli/sharedptrdatum.h b/sli/sharedptrdatum.h index 6b1ebbe8bb..8e09aaf0ac 100644 --- a/sli/sharedptrdatum.h +++ b/sli/sharedptrdatum.h @@ -35,7 +35,7 @@ template < class D, SLIType* slt > class sharedPtrDatum : public std::shared_ptr< D >, public TypedDatum< slt > { Datum* - clone( void ) const + clone( ) const { return new sharedPtrDatum< D, slt >( *this ); } diff --git a/sli/sli_io.cc b/sli/sli_io.cc index 3fb2943646..c8188bb67e 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -79,7 +79,7 @@ MathLinkPutStringFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { StringDatum const d; Token t = i->OStack.top(); @@ -113,7 +113,7 @@ XIfstreamFunction::execute( SLIInterpreter* i ) const // -> false StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { StringDatum const d; Token t = i->OStack.top(); @@ -157,7 +157,7 @@ IfstreamFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { StringDatum const d; Token t = i->OStack.top(); @@ -205,7 +205,7 @@ OfstreamFunction::execute( SLIInterpreter* i ) const // -> false StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { StringDatum const d; Token t = i->OStack.top(); @@ -267,7 +267,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const StringDatum* md = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL || md == NULL ) + if ( sd == nullptr || md == nullptr ) { StringDatum const d; Token t1 = i->OStack.pick( 1 ); @@ -276,7 +276,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const t1.datum()->gettypename().toString() + " or " + t2.datum()->gettypename().toString() ); } - std::ostream* out = NULL; + std::ostream* out = nullptr; if ( static_cast< string >( *md ) == "w" ) { @@ -292,7 +292,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const return; } - if ( out != NULL ) + if ( out != nullptr ) { i->OStack.pop( 2 ); if ( out->good() ) @@ -330,7 +330,7 @@ IsstreamFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { StringDatum const d; Token t = i->OStack.top(); @@ -404,7 +404,7 @@ StrSStreamFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == NULL ) + if ( ostreamdatum == nullptr ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -416,10 +416,10 @@ StrSStreamFunction::execute( SLIInterpreter* i ) const #else std::ostrstream* out = dynamic_cast< std::ostrstream* >( ostreamdatum->get() ); #endif - assert( out != NULL ); + assert( out != nullptr ); ostreamdatum->unlock(); - if ( out != NULL ) + if ( out != nullptr ) { if ( out->good() ) { @@ -564,7 +564,7 @@ PrintFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == NULL ) + if ( ostreamdatum == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -610,7 +610,7 @@ PrettyprintFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -642,7 +642,7 @@ FlushFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -682,7 +682,7 @@ EndlFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -710,7 +710,7 @@ EndsFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -735,7 +735,7 @@ EatwhiteFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == NULL || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -766,7 +766,7 @@ CloseistreamFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == NULL || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -781,7 +781,7 @@ CloseistreamFunction::execute( SLIInterpreter* i ) const // the datum conatains &std::cin !! ifdstream* ifs = dynamic_cast< ifdstream* >( istreamdatum->get() ); istreamdatum->unlock(); - if ( ifs != NULL ) + if ( ifs != nullptr ) { ifs->close(); // iostreamhandle->destroy(); @@ -814,7 +814,7 @@ CloseostreamFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == NULL ) + if ( ostreamdatum == nullptr ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -829,7 +829,7 @@ CloseostreamFunction::execute( SLIInterpreter* i ) const ofdstream* ofs = dynamic_cast< ofdstream* >( ostreamdatum->get() ); ostreamdatum->unlock(); - if ( ofs != NULL ) + if ( ofs != nullptr ) { ofs->close(); i->OStack.pop(); @@ -855,7 +855,7 @@ SetwFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -864,7 +864,7 @@ SetwFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( id == NULL ) + if ( id == nullptr ) { IntegerDatum const d; Token t = i->OStack.top(); @@ -906,7 +906,7 @@ SetprecisionFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -915,7 +915,7 @@ SetprecisionFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( id == NULL ) + if ( id == nullptr ) { IntegerDatum const d; Token t = i->OStack.top(); @@ -943,7 +943,7 @@ IOSFixedFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -971,7 +971,7 @@ IOSScientificFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -999,7 +999,7 @@ IOSDefaultFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1027,7 +1027,7 @@ IOSShowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1054,7 +1054,7 @@ IOSNoshowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1082,7 +1082,7 @@ IOSOctFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1109,7 +1109,7 @@ IOSHexFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1136,7 +1136,7 @@ IOSDecFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1163,7 +1163,7 @@ IOSShowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1190,7 +1190,7 @@ IOSNoshowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1217,7 +1217,7 @@ IOSLeftFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1246,7 +1246,7 @@ IOSRightFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1275,7 +1275,7 @@ IOSInternalFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == NULL || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1316,7 +1316,7 @@ GetcFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == NULL || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1356,7 +1356,7 @@ GetsFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1405,7 +1405,7 @@ GetlineFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1459,7 +1459,7 @@ IGoodFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1500,7 +1500,7 @@ IClearFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1534,7 +1534,7 @@ OClearFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == 0 || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1569,7 +1569,7 @@ IFailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1611,7 +1611,7 @@ OGoodFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == 0 || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1652,7 +1652,7 @@ IEofFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1694,7 +1694,7 @@ OEofFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == 0 || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1720,7 +1720,7 @@ Cvx_fFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); IstreamDatum* sd = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( sd != NULL ) + if ( sd != nullptr ) { Token handle_token( new XIstreamDatum( *sd ) ); i->OStack.pop(); @@ -1749,7 +1749,7 @@ In_AvailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1775,7 +1775,7 @@ ReadDoubleFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 ) + if ( istreamdatum == nullptr ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1817,7 +1817,7 @@ ReadIntFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 ) + if ( istreamdatum == nullptr ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1866,7 +1866,7 @@ ReadWordFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == 0 || not istreamdatum->valid() ) + if ( istreamdatum == nullptr || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); diff --git a/sli/sli_io.h b/sli/sli_io.h index dc17b16b4c..a7203dbf03 100644 --- a/sli/sli_io.h +++ b/sli/sli_io.h @@ -41,7 +41,7 @@ class MathLinkPutStringFunction : public SLIFunction MathLinkPutStringFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class XIfstreamFunction : public SLIFunction @@ -50,7 +50,7 @@ class XIfstreamFunction : public SLIFunction XIfstreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IfstreamFunction : public SLIFunction @@ -59,7 +59,7 @@ class IfstreamFunction : public SLIFunction IfstreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OfstreamFunction : public SLIFunction @@ -68,7 +68,7 @@ class OfstreamFunction : public SLIFunction OfstreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OfsopenFunction : public SLIFunction @@ -77,7 +77,7 @@ class OfsopenFunction : public SLIFunction OfsopenFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #ifdef HAVE_SSTREAM @@ -88,7 +88,7 @@ class IsstreamFunction : public SLIFunction IsstreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OsstreamFunction : public SLIFunction @@ -97,7 +97,7 @@ class OsstreamFunction : public SLIFunction OsstreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class StrSStreamFunction : public SLIFunction @@ -106,7 +106,7 @@ class StrSStreamFunction : public SLIFunction StrSStreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #else @@ -135,7 +135,7 @@ class PrintFunction : public SLIFunction PrintFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PrettyprintFunction : public SLIFunction @@ -144,7 +144,7 @@ class PrettyprintFunction : public SLIFunction PrettyprintFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CloseistreamFunction : public SLIFunction @@ -153,7 +153,7 @@ class CloseistreamFunction : public SLIFunction CloseistreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CloseostreamFunction : public SLIFunction @@ -162,7 +162,7 @@ class CloseostreamFunction : public SLIFunction CloseostreamFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class FlushFunction : public SLIFunction @@ -171,7 +171,7 @@ class FlushFunction : public SLIFunction FlushFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class EndlFunction : public SLIFunction @@ -180,7 +180,7 @@ class EndlFunction : public SLIFunction EndlFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class EndsFunction : public SLIFunction @@ -189,7 +189,7 @@ class EndsFunction : public SLIFunction EndsFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class EatwhiteFunction : public SLIFunction @@ -198,7 +198,7 @@ class EatwhiteFunction : public SLIFunction EatwhiteFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetwFunction : public SLIFunction @@ -207,7 +207,7 @@ class SetwFunction : public SLIFunction SetwFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetprecisionFunction : public SLIFunction @@ -216,7 +216,7 @@ class SetprecisionFunction : public SLIFunction SetprecisionFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSFixedFunction : public SLIFunction @@ -225,7 +225,7 @@ class IOSFixedFunction : public SLIFunction IOSFixedFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSScientificFunction : public SLIFunction @@ -234,7 +234,7 @@ class IOSScientificFunction : public SLIFunction IOSScientificFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSDefaultFunction : public SLIFunction @@ -243,7 +243,7 @@ class IOSDefaultFunction : public SLIFunction IOSDefaultFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSShowpointFunction : public SLIFunction @@ -252,7 +252,7 @@ class IOSShowpointFunction : public SLIFunction IOSShowpointFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSNoshowpointFunction : public SLIFunction @@ -261,7 +261,7 @@ class IOSNoshowpointFunction : public SLIFunction IOSNoshowpointFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSShowbaseFunction : public SLIFunction @@ -270,7 +270,7 @@ class IOSShowbaseFunction : public SLIFunction IOSShowbaseFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSNoshowbaseFunction : public SLIFunction @@ -279,7 +279,7 @@ class IOSNoshowbaseFunction : public SLIFunction IOSNoshowbaseFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSDecFunction : public SLIFunction @@ -288,7 +288,7 @@ class IOSDecFunction : public SLIFunction IOSDecFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSHexFunction : public SLIFunction @@ -297,7 +297,7 @@ class IOSHexFunction : public SLIFunction IOSHexFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSOctFunction : public SLIFunction @@ -306,7 +306,7 @@ class IOSOctFunction : public SLIFunction IOSOctFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSLeftFunction : public SLIFunction @@ -315,7 +315,7 @@ class IOSLeftFunction : public SLIFunction IOSLeftFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSRightFunction : public SLIFunction @@ -324,7 +324,7 @@ class IOSRightFunction : public SLIFunction IOSRightFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IOSInternalFunction : public SLIFunction @@ -333,7 +333,7 @@ class IOSInternalFunction : public SLIFunction IOSInternalFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GetcFunction : public SLIFunction @@ -342,7 +342,7 @@ class GetcFunction : public SLIFunction GetcFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GetsFunction : public SLIFunction @@ -351,7 +351,7 @@ class GetsFunction : public SLIFunction GetsFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GetlineFunction : public SLIFunction @@ -360,7 +360,7 @@ class GetlineFunction : public SLIFunction GetlineFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IGoodFunction : public SLIFunction @@ -369,7 +369,7 @@ class IGoodFunction : public SLIFunction IGoodFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IClearFunction : public SLIFunction @@ -378,7 +378,7 @@ class IClearFunction : public SLIFunction IClearFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OClearFunction : public SLIFunction @@ -387,7 +387,7 @@ class OClearFunction : public SLIFunction OClearFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IFailFunction : public SLIFunction @@ -396,7 +396,7 @@ class IFailFunction : public SLIFunction IFailFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OGoodFunction : public SLIFunction @@ -405,7 +405,7 @@ class OGoodFunction : public SLIFunction OGoodFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvx_fFunction : public SLIFunction @@ -414,7 +414,7 @@ class Cvx_fFunction : public SLIFunction Cvx_fFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IEofFunction : public SLIFunction @@ -423,7 +423,7 @@ class IEofFunction : public SLIFunction IEofFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OEofFunction : public SLIFunction @@ -432,7 +432,7 @@ class OEofFunction : public SLIFunction OEofFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class In_AvailFunction : public SLIFunction @@ -441,7 +441,7 @@ class In_AvailFunction : public SLIFunction In_AvailFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ReadDoubleFunction : public SLIFunction @@ -450,7 +450,7 @@ class ReadDoubleFunction : public SLIFunction ReadDoubleFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ReadIntFunction : public SLIFunction @@ -459,7 +459,7 @@ class ReadIntFunction : public SLIFunction ReadIntFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ReadWordFunction : public SLIFunction @@ -468,7 +468,7 @@ class ReadWordFunction : public SLIFunction ReadWordFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/sliactions.cc b/sli/sliactions.cc index 8b722fc9f8..1fb5321037 100644 --- a/sli/sliactions.cc +++ b/sli/sliactions.cc @@ -89,7 +89,7 @@ FunctiontypeFunction::execute( SLIInterpreter* i ) const if ( i->step_mode() ) { std::cerr << "Calling builtin function: "; - if ( fd != NULL ) + if ( fd != nullptr ) { fd->pprint( std::cerr ); } diff --git a/sli/sliactions.h b/sli/sliactions.h index 55e337c48d..6267f6a7c5 100644 --- a/sli/sliactions.h +++ b/sli/sliactions.h @@ -35,7 +35,7 @@ class DatatypeFunction : public SLIFunction DatatypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class NametypeFunction : public SLIFunction @@ -44,7 +44,7 @@ class NametypeFunction : public SLIFunction NametypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ProceduretypeFunction : public SLIFunction @@ -53,7 +53,7 @@ class ProceduretypeFunction : public SLIFunction ProceduretypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LitproceduretypeFunction : public SLIFunction @@ -62,7 +62,7 @@ class LitproceduretypeFunction : public SLIFunction LitproceduretypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class FunctiontypeFunction : public SLIFunction @@ -71,7 +71,7 @@ class FunctiontypeFunction : public SLIFunction FunctiontypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CallbacktypeFunction : public SLIFunction @@ -80,7 +80,7 @@ class CallbacktypeFunction : public SLIFunction CallbacktypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class XIstreamtypeFunction : public SLIFunction @@ -89,7 +89,7 @@ class XIstreamtypeFunction : public SLIFunction XIstreamtypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class XIfstreamtypeFunction : public SLIFunction @@ -98,7 +98,7 @@ class XIfstreamtypeFunction : public SLIFunction XIfstreamtypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class TrietypeFunction : public SLIFunction @@ -107,7 +107,7 @@ class TrietypeFunction : public SLIFunction TrietypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/sliarray.h b/sli/sliarray.h index b553341e1e..8cdd8f0d8e 100644 --- a/sli/sliarray.h +++ b/sli/sliarray.h @@ -44,130 +44,130 @@ class SLIArrayModule : public SLIModule class MapFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IMapFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IMap_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IMap_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class MapThreadFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IMapThreadFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class MapIndexedFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IMapIndexedFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class RangeFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ArraystoreFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ArrayloadFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ArraycreateFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ReverseFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RotateFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class FlattenFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SortFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UniqueFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class TransposeFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PartitionFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ValidFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_a_a_tFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @@ -207,7 +207,7 @@ class SLIArrayModule : public SLIModule class AreaFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @@ -245,31 +245,31 @@ class SLIArrayModule : public SLIModule class Area2Function : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cv1dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cv2dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GetMaxFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GetMinFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -283,7 +283,7 @@ class SLIArrayModule : public SLIModule { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @@ -296,7 +296,7 @@ class SLIArrayModule : public SLIModule { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -310,7 +310,7 @@ class SLIArrayModule : public SLIModule Array2IntVectorFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @@ -323,7 +323,7 @@ class SLIArrayModule : public SLIModule Array2DoubleVectorFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DoubleVector2ArrayFunction : public SLIFunction @@ -332,7 +332,7 @@ class SLIArrayModule : public SLIModule DoubleVector2ArrayFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IntVector2ArrayFunction : public SLIFunction @@ -341,156 +341,156 @@ class SLIArrayModule : public SLIModule IntVector2ArrayFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_iv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_i_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Neg_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sub_iv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_iv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_i_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_d_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Div_iv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_dv_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_d_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sub_dv_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_dv_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_d_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Div_dv_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Neg_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Inv_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_iv_iFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_iv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_dv_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_dv_iFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_dv_i_dFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_iv_i_iFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Zeros_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Zeros_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Ones_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Ones_ivFunction : public SLIFunction { @@ -515,46 +515,46 @@ class SLIArrayModule : public SLIModule FiniteQ_dFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forall_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forall_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Iforall_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class Iforall_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class Eq_dvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Eq_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @} */ @@ -636,9 +636,9 @@ class SLIArrayModule : public SLIModule { } - void init( SLIInterpreter* ); - const std::string commandstring( void ) const; - const std::string name( void ) const; + void init( SLIInterpreter* ) override; + const std::string commandstring( ) const override; + const std::string name( ) const override; }; diff --git a/sli/slibuiltins.cc b/sli/slibuiltins.cc index caba206339..92ed2c219b 100644 --- a/sli/slibuiltins.cc +++ b/sli/slibuiltins.cc @@ -46,7 +46,7 @@ IsetcallbackFunction::execute( SLIInterpreter* i ) const // move the hopefully present callback action // into the interpreters callback token. i->EStack.pop(); - assert( dynamic_cast< CallbackDatum* >( i->EStack.top().datum() ) != NULL ); + assert( dynamic_cast< CallbackDatum* >( i->EStack.top().datum() ) != nullptr ); i->EStack.pop_move( i->ct ); } @@ -54,10 +54,10 @@ void IiterateFunction::backtrace( SLIInterpreter* i, int p ) const { ProcedureDatum const* pd = dynamic_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); std::cerr << "In procedure:" << std::endl; @@ -133,10 +133,10 @@ void IloopFunction::backtrace( SLIInterpreter* i, int p ) const { ProcedureDatum const* pd = dynamic_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); std::cerr << "During loop:" << std::endl; @@ -185,13 +185,13 @@ void IrepeatFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); std::cerr << "During repeat with " << count->get() << " iterations remaining." << std::endl; @@ -252,11 +252,11 @@ void IforFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); std::cerr << "During for at iterator value " << count->get() << "." << std::endl; @@ -315,7 +315,7 @@ void IforallarrayFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forall (array) at iteration " << count->get() << "." << std::endl; } @@ -353,7 +353,7 @@ void IforallindexedarrayFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forallindexed (array) at iteration " << count->get() - 1 << "." << std::endl; } @@ -362,7 +362,7 @@ void IforallindexedstringFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forallindexed (string) at iteration " << count->get() - 1 << "." << std::endl; } @@ -405,7 +405,7 @@ void IforallstringFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forall (string) at iteration " << count->get() - 1 << "." << std::endl; } diff --git a/sli/slibuiltins.h b/sli/slibuiltins.h index 4bca1bd6fb..c4ab25483c 100644 --- a/sli/slibuiltins.h +++ b/sli/slibuiltins.h @@ -45,7 +45,7 @@ class IlookupFunction : public SLIFunction IlookupFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IsetcallbackFunction : public SLIFunction @@ -54,7 +54,7 @@ class IsetcallbackFunction : public SLIFunction IsetcallbackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IiterateFunction : public SLIFunction @@ -63,8 +63,8 @@ class IiterateFunction : public SLIFunction IiterateFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IloopFunction : public SLIFunction @@ -73,8 +73,8 @@ class IloopFunction : public SLIFunction IloopFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IrepeatFunction : public SLIFunction @@ -83,8 +83,8 @@ class IrepeatFunction : public SLIFunction IrepeatFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IforFunction : public SLIFunction @@ -93,8 +93,8 @@ class IforFunction : public SLIFunction IforFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IforallarrayFunction : public SLIFunction @@ -103,8 +103,8 @@ class IforallarrayFunction : public SLIFunction IforallarrayFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IforallindexedarrayFunction : public SLIFunction @@ -113,8 +113,8 @@ class IforallindexedarrayFunction : public SLIFunction IforallindexedarrayFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IforallindexedstringFunction : public SLIFunction @@ -123,8 +123,8 @@ class IforallindexedstringFunction : public SLIFunction IforallindexedstringFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; class IforallstringFunction : public SLIFunction @@ -133,8 +133,8 @@ class IforallstringFunction : public SLIFunction IforallstringFunction() { } - void execute( SLIInterpreter* ) const; - void backtrace( SLIInterpreter*, int ) const; + void execute( SLIInterpreter* ) const override; + void backtrace( SLIInterpreter*, int ) const override; }; diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index 72f73a9735..7057ce6474 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -343,7 +343,7 @@ RepeatFunction::execute( SLIInterpreter* i ) const if ( proc ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { throw ArgumentType( 1 ); } @@ -1706,7 +1706,7 @@ PgetrusageFunction::getinfo_( int who, DictionaryDatum& dict ) const void TimeFunction::execute( SLIInterpreter* i ) const { - long secs = time( 0 ); + long secs = time( nullptr ); Token tmp( new IntegerDatum( secs ) ); i->EStack.pop(); i->OStack.push_move( tmp ); diff --git a/sli/slicontrol.h b/sli/slicontrol.h index fa919dda53..455eb3dfb3 100644 --- a/sli/slicontrol.h +++ b/sli/slicontrol.h @@ -43,7 +43,7 @@ class Backtrace_onFunction : public SLIFunction Backtrace_onFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Backtrace_offFunction : public SLIFunction @@ -52,7 +52,7 @@ class Backtrace_offFunction : public SLIFunction Backtrace_offFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OStackdumpFunction : public SLIFunction @@ -61,7 +61,7 @@ class OStackdumpFunction : public SLIFunction OStackdumpFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class EStackdumpFunction : public SLIFunction @@ -70,7 +70,7 @@ class EStackdumpFunction : public SLIFunction EStackdumpFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LoopFunction : public SLIFunction @@ -79,7 +79,7 @@ class LoopFunction : public SLIFunction LoopFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ExitFunction : public SLIFunction @@ -88,7 +88,7 @@ class ExitFunction : public SLIFunction ExitFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class QuitFunction : public SLIFunction @@ -97,7 +97,7 @@ class QuitFunction : public SLIFunction QuitFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IfFunction : public SLIFunction @@ -106,7 +106,7 @@ class IfFunction : public SLIFunction IfFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IfelseFunction : public SLIFunction @@ -115,7 +115,7 @@ class IfelseFunction : public SLIFunction IfelseFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RepeatFunction : public SLIFunction @@ -124,7 +124,7 @@ class RepeatFunction : public SLIFunction RepeatFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CloseinputFunction : public SLIFunction @@ -133,7 +133,7 @@ class CloseinputFunction : public SLIFunction CloseinputFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class StoppedFunction : public SLIFunction @@ -142,7 +142,7 @@ class StoppedFunction : public SLIFunction StoppedFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class StopFunction : public SLIFunction @@ -151,7 +151,7 @@ class StopFunction : public SLIFunction StopFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CurrentnameFunction : public SLIFunction @@ -160,7 +160,7 @@ class CurrentnameFunction : public SLIFunction CurrentnameFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IparsestdinFunction : public SLIFunction @@ -169,7 +169,7 @@ class IparsestdinFunction : public SLIFunction IparsestdinFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class StartFunction : public SLIFunction @@ -178,7 +178,7 @@ class StartFunction : public SLIFunction StartFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ParsestdinFunction : public SLIFunction @@ -187,7 +187,7 @@ class ParsestdinFunction : public SLIFunction ParsestdinFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IparseFunction : public SLIFunction @@ -196,7 +196,7 @@ class IparseFunction : public SLIFunction IparseFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DefFunction : public SLIFunction @@ -205,7 +205,7 @@ class DefFunction : public SLIFunction DefFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetFunction : public SLIFunction @@ -214,7 +214,7 @@ class SetFunction : public SLIFunction SetFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LoadFunction : public SLIFunction @@ -223,7 +223,7 @@ class LoadFunction : public SLIFunction LoadFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LookupFunction : public SLIFunction @@ -232,7 +232,7 @@ class LookupFunction : public SLIFunction LookupFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ForFunction : public SLIFunction @@ -241,7 +241,7 @@ class ForFunction : public SLIFunction ForFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forall_aFunction : public SLIFunction @@ -250,7 +250,7 @@ class Forall_aFunction : public SLIFunction Forall_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forallindexed_aFunction : public SLIFunction @@ -259,7 +259,7 @@ class Forallindexed_aFunction : public SLIFunction Forallindexed_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forallindexed_sFunction : public SLIFunction @@ -268,7 +268,7 @@ class Forallindexed_sFunction : public SLIFunction Forallindexed_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Forall_sFunction : public SLIFunction @@ -277,7 +277,7 @@ class Forall_sFunction : public SLIFunction Forall_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RaiseerrorFunction : public SLIFunction @@ -286,7 +286,7 @@ class RaiseerrorFunction : public SLIFunction RaiseerrorFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PrinterrorFunction : public SLIFunction @@ -295,7 +295,7 @@ class PrinterrorFunction : public SLIFunction PrinterrorFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RaiseagainFunction : public SLIFunction @@ -304,7 +304,7 @@ class RaiseagainFunction : public SLIFunction RaiseagainFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CyclesFunction : public SLIFunction @@ -313,7 +313,7 @@ class CyclesFunction : public SLIFunction CyclesFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CodeAccessedFunction : public SLIFunction @@ -322,7 +322,7 @@ class CodeAccessedFunction : public SLIFunction CodeAccessedFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CodeExecutedFunction : public SLIFunction @@ -331,7 +331,7 @@ class CodeExecutedFunction : public SLIFunction CodeExecutedFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ExecFunction : public SLIFunction @@ -340,7 +340,7 @@ class ExecFunction : public SLIFunction ExecFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -350,7 +350,7 @@ class TypeinfoFunction : public SLIFunction TypeinfoFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @BeginDocumentation @@ -390,7 +390,7 @@ class SwitchFunction : public SLIFunction SwitchFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @BeginDocumentation @@ -442,7 +442,7 @@ class SwitchdefaultFunction : public SLIFunction SwitchdefaultFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** @BeginDocumentation @@ -485,7 +485,7 @@ class CaseFunction : public SLIFunction CaseFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CounttomarkFunction : public SLIFunction @@ -494,7 +494,7 @@ class CounttomarkFunction : public SLIFunction CounttomarkFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PclocksFunction : public SLIFunction @@ -503,7 +503,7 @@ class PclocksFunction : public SLIFunction PclocksFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PclockspersecFunction : public SLIFunction @@ -512,7 +512,7 @@ class PclockspersecFunction : public SLIFunction PclockspersecFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class PgetrusageFunction : public SLIFunction @@ -521,7 +521,7 @@ class PgetrusageFunction : public SLIFunction PgetrusageFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; private: bool getinfo_( int, DictionaryDatum& ) const; @@ -533,7 +533,7 @@ class TimeFunction : public SLIFunction TimeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sleep_dFunction : public SLIFunction @@ -542,7 +542,7 @@ class Sleep_dFunction : public SLIFunction Sleep_dFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Token_sFunction : public SLIFunction @@ -551,7 +551,7 @@ class Token_sFunction : public SLIFunction Token_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Token_isFunction : public SLIFunction @@ -560,7 +560,7 @@ class Token_isFunction : public SLIFunction Token_isFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Symbol_sFunction : public SLIFunction @@ -569,7 +569,7 @@ class Symbol_sFunction : public SLIFunction Symbol_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetGuardFunction : public SLIFunction @@ -578,7 +578,7 @@ class SetGuardFunction : public SLIFunction SetGuardFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RemoveGuardFunction : public SLIFunction @@ -587,7 +587,7 @@ class RemoveGuardFunction : public SLIFunction RemoveGuardFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class MessageFunction : public SLIFunction @@ -596,7 +596,7 @@ class MessageFunction : public SLIFunction MessageFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class SetVerbosityFunction : public SLIFunction @@ -605,7 +605,7 @@ class SetVerbosityFunction : public SLIFunction SetVerbosityFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class VerbosityFunction : public SLIFunction @@ -614,7 +614,7 @@ class VerbosityFunction : public SLIFunction VerbosityFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -624,7 +624,7 @@ class NoopFunction : public SLIFunction NoopFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DebugOnFunction : public SLIFunction @@ -633,7 +633,7 @@ class DebugOnFunction : public SLIFunction DebugOnFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DebugOffFunction : public SLIFunction @@ -642,7 +642,7 @@ class DebugOffFunction : public SLIFunction DebugOffFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DebugFunction : public SLIFunction @@ -651,7 +651,7 @@ class DebugFunction : public SLIFunction DebugFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; diff --git a/sli/slimath.cc b/sli/slimath.cc index 101b196522..f50b5f4930 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -1121,7 +1121,7 @@ OrFunction::execute( SLIInterpreter* i ) const BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); assert( op1 != NULL && op2 != NULL ); - op1->get() = ( op1->get() == true || op2->get() == true ); + op1->get() = ( op1->get() == true || op2->get() ); i->OStack.pop(); } diff --git a/sli/sliregexp.cc b/sli/sliregexp.cc index d84a5d7b84..ac79b056ae 100644 --- a/sli/sliregexp.cc +++ b/sli/sliregexp.cc @@ -135,7 +135,7 @@ RegexpModule::RegcompFunction::execute( SLIInterpreter* i ) const Token it( new IntegerDatum( e ) ); i->OStack.push_move( it ); i->OStack.push( i->baselookup( i->false_name ) ); - }; + } i->EStack.pop(); } diff --git a/sli/specialfunctionsmodule.cc b/sli/specialfunctionsmodule.cc index 0347617d21..e88e6dd2b2 100644 --- a/sli/specialfunctionsmodule.cc +++ b/sli/specialfunctionsmodule.cc @@ -61,7 +61,7 @@ const SpecialFunctionsModule::LambertWm1Function lambertwm1function; // GSL independent code const std::string -SpecialFunctionsModule::name( void ) const +SpecialFunctionsModule::name( ) const { return std::string( "SpecialFunctionsModule" ); // Return name of the module } @@ -275,7 +275,7 @@ SpecialFunctionsModule::ErfcFunction::execute( SLIInterpreter* i ) const gsl_function SpecialFunctionsModule::GaussDiskConvFunction::F_; -SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction( void ) +SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction( ) { // allocate integration workspace w_ = gsl_integration_workspace_alloc( MAX_QUAD_SIZE ); @@ -284,7 +284,7 @@ SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction( void ) F_.function = SpecialFunctionsModule::GaussDiskConvFunction::f_; } -SpecialFunctionsModule::GaussDiskConvFunction::~GaussDiskConvFunction( void ) +SpecialFunctionsModule::GaussDiskConvFunction::~GaussDiskConvFunction( ) { // free integration workspace gsl_integration_workspace_free( w_ ); diff --git a/sli/specialfunctionsmodule.h b/sli/specialfunctionsmodule.h index 6a070c720d..361f1e18d4 100644 --- a/sli/specialfunctionsmodule.h +++ b/sli/specialfunctionsmodule.h @@ -53,14 +53,14 @@ class SpecialFunctionsModule : public SLIModule // Part 1: Methods pertaining to the module ---------------------- public: - SpecialFunctionsModule( void ) {}; + SpecialFunctionsModule( ) {}; // ~SpecialFunctionsModule(void); // The Module is registered by a call to this Function: - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; // This function will return the name of our module: - const std::string name( void ) const; + const std::string name( ) const override; // Part 2: Classes for the implemented functions ----------------- @@ -78,7 +78,7 @@ class SpecialFunctionsModule : public SLIModule GammaIncFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LambertW0Function : public SLIFunction { @@ -86,7 +86,7 @@ class SpecialFunctionsModule : public SLIModule LambertW0Function() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class LambertWm1Function : public SLIFunction { @@ -94,7 +94,7 @@ class SpecialFunctionsModule : public SLIModule LambertWm1Function() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ErfFunction : public SLIFunction @@ -103,7 +103,7 @@ class SpecialFunctionsModule : public SLIModule ErfFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ErfcFunction : public SLIFunction @@ -112,17 +112,17 @@ class SpecialFunctionsModule : public SLIModule ErfcFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class GaussDiskConvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; // need constructor and destructor to set up integration workspace - GaussDiskConvFunction( void ); - ~GaussDiskConvFunction( void ); + GaussDiskConvFunction( ); + ~GaussDiskConvFunction( ) override; private: // quadrature parameters, see GSL Reference diff --git a/sli/stringdatum.h b/sli/stringdatum.h index 38a445f09d..5d55917993 100644 --- a/sli/stringdatum.h +++ b/sli/stringdatum.h @@ -84,7 +84,7 @@ class ToUppercase_sFunction : public SLIFunction ToUppercase_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ToLowercase_sFunction : public SLIFunction @@ -93,7 +93,7 @@ class ToLowercase_sFunction : public SLIFunction ToLowercase_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/symboldatum.h b/sli/symboldatum.h index 37e8517a15..14b1d870ed 100644 --- a/sli/symboldatum.h +++ b/sli/symboldatum.h @@ -51,7 +51,7 @@ sli::pool AggregateDatum< Name, &SLIInterpreter::Symboltype >::memory; class SymbolDatum : public AggregateDatum< Name, &SLIInterpreter::Symboltype > { Datum* - clone( void ) const + clone( ) const override { return new SymbolDatum( *this ); } @@ -65,7 +65,7 @@ class SymbolDatum : public AggregateDatum< Name, &SLIInterpreter::Symboltype > : AggregateDatum< Name, &SLIInterpreter::Symboltype >( n ) { } - ~SymbolDatum() + ~SymbolDatum() override { } }; diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index c487074c99..6ce9e2c05f 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -34,9 +34,9 @@ size_t TokenArrayObj::allocations = 0; TokenArrayObj::TokenArrayObj( size_t s, const Token& t, size_t alloc ) - : p( NULL ) - , begin_of_free_storage( NULL ) - , end_of_free_storage( NULL ) + : p( nullptr ) + , begin_of_free_storage( nullptr ) + , end_of_free_storage( nullptr ) , alloc_block_size( ARRAY_ALLOC_SIZE ) , refs_( 1 ) { @@ -47,13 +47,13 @@ TokenArrayObj::TokenArrayObj( size_t s, const Token& t, size_t alloc ) TokenArrayObj::TokenArrayObj( const TokenArrayObj& a ) - : p( NULL ) - , begin_of_free_storage( NULL ) - , end_of_free_storage( NULL ) + : p( nullptr ) + , begin_of_free_storage( nullptr ) + , end_of_free_storage( nullptr ) , alloc_block_size( ARRAY_ALLOC_SIZE ) , refs_( 1 ) { - if ( a.p != NULL ) + if ( a.p != nullptr ) { resize( a.size(), a.alloc_block_size, Token() ); Token* from = a.p; @@ -85,7 +85,7 @@ TokenArrayObj::allocate( size_t new_s, size_t new_c, size_t new_a, const Token& size_t old_s = size(); - assert( new_c != 0 ); + assert( new_c != 0 ) assert( new_a != 0 ); Token* h = new Token[ new_c ]; @@ -102,7 +102,7 @@ TokenArrayObj::allocate( size_t new_s, size_t new_c, size_t new_a, const Token& end_of_free_storage = h + new_c; // [,) convention begin_of_free_storage = h + new_s; - if ( p != NULL ) + if ( p != nullptr ) { size_t min_l; @@ -170,10 +170,10 @@ TokenArrayObj::operator=( const TokenArrayObj& a ) else { - if ( p != NULL ) + if ( p != nullptr ) { delete[] p; - p = NULL; + p = nullptr; } resize( a.size(), a.alloc_block_size ); @@ -211,7 +211,7 @@ TokenArrayObj::operator=( const TokenArrayObj& a ) // } bool -TokenArrayObj::shrink( void ) +TokenArrayObj::shrink( ) { size_t new_capacity = size(); @@ -282,7 +282,7 @@ TokenArrayObj::erase( Token* first, Token* last ) to->p->removeReference(); } to->p = from->p; // move - from->p = NULL; // might be overwritten or not + from->p = nullptr; // might be overwritten or not ++from; ++to; } @@ -295,7 +295,7 @@ TokenArrayObj::erase( Token* first, Token* last ) // elements which are still intact last->p->removeReference(); } - last->p = NULL; // after the move above. + last->p = nullptr; // after the move above. } begin_of_free_storage = to; @@ -317,13 +317,13 @@ TokenArrayObj::erase( size_t i, size_t n ) } void -TokenArrayObj::clear( void ) +TokenArrayObj::clear( ) { if ( p ) { delete[] p; } - p = begin_of_free_storage = end_of_free_storage = NULL; + p = begin_of_free_storage = end_of_free_storage = nullptr; alloc_block_size = 1; } @@ -397,7 +397,7 @@ TokenArrayObj::insert( size_t i, size_t n, const Token& t ) while ( from >= pos ) { to->p = from->p; // move - from->p = NULL; // knowing that to->p is + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } @@ -424,7 +424,7 @@ TokenArrayObj::insert_move( size_t i, TokenArrayObj& a ) while ( from >= pos ) { to->p = from->p; // move - from->p = NULL; // knowing that to->p is + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } @@ -435,7 +435,7 @@ TokenArrayObj::insert_move( size_t i, TokenArrayObj& a ) while ( from < a.end() ) { to->p = from->p; // we cannot do this in the loop - from->p = NULL; // above because of overlapping + from->p = nullptr; // above because of overlapping ++from; ++to; } @@ -456,7 +456,7 @@ TokenArrayObj::assign_move( TokenArrayObj& a, size_t i, size_t n ) while ( from < end ) { to->p = from->p; - from->p = NULL; + from->p = nullptr; ++from; ++to; } @@ -496,13 +496,13 @@ TokenArrayObj::insert_move( size_t i, Token& t ) while ( from >= pos ) { to->p = from->p; // move - from->p = NULL; // knowing that to->p is + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } ( p + i )->p = t.p; // move contens of t - t.p = NULL; + t.p = nullptr; begin_of_free_storage += 1; // new size is old + 1 } @@ -531,7 +531,7 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) while ( from > end ) { to->p = from->p; // move - from->p = NULL; // might be overwritten or not + from->p = nullptr; // might be overwritten or not --from; --to; } @@ -553,7 +553,7 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) to->p->removeReference(); } to->p = from->p; // move - from->p = NULL; // might be overwritten or not + from->p = nullptr; // might be overwritten or not ++from; ++to; } @@ -566,7 +566,7 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) // elements which are still intact last->p->removeReference(); } - last->p = NULL; // after the move above. + last->p = nullptr; // after the move above. } } @@ -586,7 +586,7 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) to->p->removeReference(); } to->p = from->p; // movement, it is typically - from->p = NULL; // not the NULL pointer + from->p = nullptr; // not the NULL pointer ++from; ++to; } @@ -604,7 +604,7 @@ TokenArrayObj::append_move( TokenArrayObj& a ) while ( from < a.end() ) // move { // knowing that to->p is to->p = from->p; // NULL before - from->p = NULL; + from->p = nullptr; ++from; ++to; } @@ -660,21 +660,21 @@ TokenArrayObj::info( std::ostream& out ) const } bool -TokenArrayObj::valid( void ) const +TokenArrayObj::valid( ) const { - if ( p == NULL ) + if ( p == nullptr ) { std::cerr << "TokenArrayObj::valid: Data pointer missing!" << std::endl; return false; } - if ( begin_of_free_storage == NULL ) + if ( begin_of_free_storage == nullptr ) { std::cerr << "TokenArrayObj::valid: begin of free storage pointer missing!" << std::endl; return false; } - if ( end_of_free_storage == NULL ) + if ( end_of_free_storage == nullptr ) { std::cerr << "TokenArrayObj::valid: end of free storage pointer missing!" << std::endl; return false; diff --git a/sli/token.cc b/sli/token.cc index 7b1c64688c..50bf2e1893 100644 --- a/sli/token.cc +++ b/sli/token.cc @@ -202,5 +202,4 @@ Token::matches_as_string( const Token& rhs ) const { return false; } - return false; } diff --git a/sli/token.h b/sli/token.h index 7abbe5b3ee..229458c861 100644 --- a/sli/token.h +++ b/sli/token.h @@ -168,11 +168,11 @@ class Token { p->removeReference(); } - p = 0; + p = nullptr; } Token( const Token& c_s ) - : p( NULL ) + : p( nullptr ) { if ( c_s.p ) { @@ -184,7 +184,7 @@ class Token /** * use existing pointer to datum, token takes responsibility of the pointer. */ - Token( Datum* p_s = NULL ) + Token( Datum* p_s = nullptr ) : p( p_s ) { } @@ -208,9 +208,9 @@ class Token Token( const std::vector< double >& ); Token( const std::vector< long >& ); Token( const std::vector< size_t >& ); - Token( const std::ostream& ); - Token( const std::istream& ); - operator Datum*() const; + // Token( const std::ostream& ); + // Token( const std::istream& ); + // operator Datum*() const; operator size_t() const; operator long() const; operator double() const; @@ -241,7 +241,7 @@ class Token p->removeReference(); } p = c.p; - c.p = NULL; + c.p = nullptr; } @@ -256,7 +256,7 @@ class Token init_move( Token& rhs ) { p = rhs.p; - rhs.p = NULL; + rhs.p = nullptr; } /** @@ -317,7 +317,7 @@ class Token void assign_by_pointer( Datum* rhs ) { - assert( rhs != NULL ); + assert( rhs != nullptr ); rhs->addReference(); if ( p ) { @@ -334,35 +334,35 @@ class Token } void - clear( void ) + clear( ) { if ( p ) { p->removeReference(); } - p = NULL; + p = nullptr; } bool contains( const Datum& d ) const { - return ( p != NULL ) ? p->equals( &d ) : false; + return ( p != nullptr ) && p->equals( &d ); } bool - empty( void ) const + empty( ) const { - return p == NULL; + return p == nullptr; } bool - operator not( void ) const + operator not( ) const { - return p == NULL; + return p == nullptr; } Datum* - datum( void ) const + datum( ) const { accessed_ = true; return p; @@ -392,7 +392,7 @@ class Token const std::type_info& - type( void ) const + type( ) const { return typeid( *p ); } @@ -406,7 +406,7 @@ class Token return *this; } - if ( c_s.p == NULL ) + if ( c_s.p == nullptr ) { clear(); return *this; diff --git a/sli/tokenarray.cc b/sli/tokenarray.cc index 92e9c2f73a..2c169a5989 100644 --- a/sli/tokenarray.cc +++ b/sli/tokenarray.cc @@ -43,7 +43,7 @@ TokenArray::operator=( const TokenArray& a ) TokenArray::TokenArray( const std::vector< long >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != NULL ); + assert( data != nullptr ); for ( size_t i = 0; i < a.size(); ++i ) { Token idt( new IntegerDatum( a[ i ] ) ); @@ -54,7 +54,7 @@ TokenArray::TokenArray( const std::vector< long >& a ) TokenArray::TokenArray( const std::vector< size_t >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != NULL ); + assert( data != nullptr ); for ( size_t i = 0; i < a.size(); ++i ) { Token idt( new IntegerDatum( a[ i ] ) ); @@ -65,7 +65,7 @@ TokenArray::TokenArray( const std::vector< size_t >& a ) TokenArray::TokenArray( const std::vector< double >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != NULL ); + assert( data != nullptr ); for ( size_t i = 0; i < a.size(); ++i ) { Token ddt( new DoubleDatum( a[ i ] ) ); @@ -81,7 +81,7 @@ TokenArray::toVector( std::vector< long >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { IntegerDatum* targetid = dynamic_cast< IntegerDatum* >( idx->datum() ); - if ( targetid == NULL ) + if ( targetid == nullptr ) { IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -99,7 +99,7 @@ TokenArray::toVector( std::vector< size_t >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { IntegerDatum* targetid = dynamic_cast< IntegerDatum* >( idx->datum() ); - if ( targetid == NULL ) + if ( targetid == nullptr ) { IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -141,7 +141,7 @@ TokenArray::toVector( std::vector< std::string >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { std::string* target = dynamic_cast< std::string* >( idx->datum() ); - if ( target == NULL ) + if ( target == nullptr ) { StringDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -152,9 +152,9 @@ TokenArray::toVector( std::vector< std::string >& a ) const bool -TokenArray::valid( void ) const +TokenArray::valid( ) const { - if ( data == NULL ) + if ( data == nullptr ) { return false; } diff --git a/sli/tokenarray.h b/sli/tokenarray.h index dc64ad35b7..78a9ade76d 100644 --- a/sli/tokenarray.h +++ b/sli/tokenarray.h @@ -68,7 +68,7 @@ class TokenArray TokenArrayObj* data; bool - clone( void ) + clone( ) { if ( data->references() > 1 ) { @@ -83,7 +83,7 @@ class TokenArray } bool - detach( void ) + detach( ) { if ( data->references() > 1 ) { @@ -106,7 +106,7 @@ class TokenArray } public: - TokenArray( void ) + TokenArray( ) : data( new TokenArrayObj() ) {}; explicit TokenArray( size_t n, const Token& t = Token(), size_t alloc = 128 ) @@ -156,7 +156,7 @@ class TokenArray * Return number of elements in the array. */ size_t - size( void ) const + size( ) const { return data->size(); } @@ -165,7 +165,7 @@ class TokenArray * Return maximal number of elements that fit into the container. */ size_t - capacity( void ) const + capacity( ) const { return data->capacity(); } @@ -227,7 +227,7 @@ class TokenArray * invalidated. */ bool - shrink( void ) + shrink( ) { return data->shrink(); } @@ -244,7 +244,7 @@ class TokenArray } unsigned int - references( void ) + references( ) { return data->references(); } @@ -360,20 +360,20 @@ class TokenArray } void - pop_back( void ) + pop_back( ) { clone(); data->pop_back(); } void - clear( void ) + clear( ) { erase(); } void - erase( void ) + erase( ) { if ( not detach() ) { @@ -425,8 +425,8 @@ class TokenArray } const TokenArray& operator=( const TokenArray& ); - const TokenArray& operator=( const std::vector< long >& ); - const TokenArray& operator=( const std::vector< double >& ); + // const TokenArray& operator=( const std::vector< long >& ); + // const TokenArray& operator=( const std::vector< double >& ); bool operator==( const TokenArray& a ) const @@ -435,12 +435,12 @@ class TokenArray } bool - empty( void ) const + empty( ) const { return size() == 0; } - void info( std::ostream& ) const; + // void info( std::ostream& ) const; /** Fill vectors with homogeneous integer and double arrays */ @@ -449,7 +449,7 @@ class TokenArray void toVector( std::vector< double >& ) const; void toVector( std::vector< std::string >& ) const; - bool valid( void ) const; // check integrity + bool valid( ) const; // check integrity /** Exception classes */ // class TypeMismatch {}; diff --git a/sli/tokenstack.h b/sli/tokenstack.h index 53f4ab8e6d..da86615cbf 100644 --- a/sli/tokenstack.h +++ b/sli/tokenstack.h @@ -52,7 +52,7 @@ class TokenStack : private TokenArrayObj using TokenArrayObj::reserve_token; void - clear( void ) + clear( ) { erase( begin(), end() ); } @@ -93,7 +93,7 @@ class TokenStack : private TokenArrayObj } void - pop( void ) + pop( ) { pop_back(); } @@ -113,12 +113,12 @@ class TokenStack : private TokenArrayObj Token& - top( void ) + top( ) { return *( end() - 1 ); } const Token& - top( void ) const + top( ) const { return *( end() - 1 ); } @@ -140,7 +140,7 @@ class TokenStack : private TokenArrayObj void - swap( void ) + swap( ) { ( end() - 1 )->swap( *( end() - 2 ) ); } @@ -176,12 +176,12 @@ class TokenStack : private TokenArrayObj } Index - size( void ) const + size( ) const { return TokenArrayObj::capacity(); } Index - load( void ) const + load( ) const { return TokenArrayObj::size(); } @@ -189,7 +189,7 @@ class TokenStack : private TokenArrayObj void dump( std::ostream& ) const; TokenArray - toArray( void ) const + toArray( ) const { return TokenArray( *this ); } diff --git a/sli/tokenutils.cc b/sli/tokenutils.cc index e717f8b505..0ed85bed7b 100644 --- a/sli/tokenutils.cc +++ b/sli/tokenutils.cc @@ -41,7 +41,7 @@ long getValue< long >( const Token& t ) { const IntegerDatum* id = dynamic_cast< const IntegerDatum* >( t.datum() ); - if ( id == NULL ) + if ( id == nullptr ) { // We have to create a Datum object to get the name... IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -53,7 +53,7 @@ void setValue< long >( const Token& t, long const& value ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == NULL ) + if ( id == nullptr ) { // We have to create a Datum object to get the name... IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -95,7 +95,7 @@ void setValue< double >( const Token& t, double const& value ) { DoubleDatum* id = dynamic_cast< DoubleDatum* >( t.datum() ); - if ( id == NULL ) + if ( id == nullptr ) { // We have to create a Datum object to get the name... DoubleDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -115,7 +115,7 @@ bool getValue< bool >( const Token& t ) { BoolDatum* bd = dynamic_cast< BoolDatum* >( t.datum() ); - if ( bd == NULL ) + if ( bd == nullptr ) { // We have to create a Datum object to get the name... BoolDatum const d( false ); throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -128,7 +128,7 @@ void setValue< bool >( const Token& t, bool const& value ) { BoolDatum* bd = dynamic_cast< BoolDatum* >( t.datum() ); - if ( bd == NULL ) + if ( bd == nullptr ) { // We have to create a Datum object to get the name... BoolDatum const d( false ); throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -155,7 +155,7 @@ getValue< std::string >( const Token& t ) { // If it is a StringDatum, it can be casted to a string: std::string* s = dynamic_cast< std::string* >( t.datum() ); - if ( s != NULL ) + if ( s != nullptr ) { return *s; } @@ -164,7 +164,7 @@ getValue< std::string >( const Token& t ) // If it is a NameDatum, LiteralDatum or SymbolDatum, // (or even a BoolDatum!) it can be casted to a Name: Name* n = dynamic_cast< Name* >( t.datum() ); - if ( n != NULL ) + if ( n != nullptr ) { return n->toString(); } @@ -188,7 +188,7 @@ setValue< std::string >( const Token& t, std::string const& value ) { // If it is a StringDatum, it can be casted to a string: std::string* s = dynamic_cast< std::string* >( t.datum() ); - if ( s != NULL ) + if ( s != nullptr ) { *s = value; } @@ -197,7 +197,7 @@ setValue< std::string >( const Token& t, std::string const& value ) // If it is a BoolDatum, it -could- be set from a string, but // this operation shall not be allowed! BoolDatum* b = dynamic_cast< BoolDatum* >( t.datum() ); - if ( b != NULL ) + if ( b != nullptr ) { // We have to create Datum objects to get the expected names... StringDatum const d1; @@ -213,7 +213,7 @@ setValue< std::string >( const Token& t, std::string const& value ) // If it is a NameDatum, LiteralDatum or SymbolDatum, // it can be casted to a Name: Name* n = dynamic_cast< Name* >( t.datum() ); - if ( n != NULL ) + if ( n != nullptr ) { *n = Name( value ); } @@ -275,7 +275,7 @@ void setValue< std::vector< double > >( const Token& t, std::vector< double > const& value ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( t.datum() ); - if ( ad == NULL ) + if ( ad == nullptr ) { // We have to create a Datum object to get the name... ArrayDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -332,7 +332,7 @@ void setValue< std::vector< long > >( const Token& t, std::vector< long > const& value ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( t.datum() ); - if ( ad == NULL ) + if ( ad == nullptr ) { // We have to create a Datum object to get the name... ArrayDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); diff --git a/sli/triedatum.cc b/sli/triedatum.cc index 05fb364ac7..51a760eab6 100644 --- a/sli/triedatum.cc +++ b/sli/triedatum.cc @@ -36,5 +36,5 @@ TrieDatum::equals( Datum const* dat ) const const TrieDatum* fd = dynamic_cast< TrieDatum* >( const_cast< Datum* >( dat ) ); - return ( fd == NULL ) ? false : ( tree == fd->tree ); + return fd != nullptr && ( tree == fd->tree ); } diff --git a/sli/triedatum.h b/sli/triedatum.h index 42c9829d19..2cc72e89a5 100644 --- a/sli/triedatum.h +++ b/sli/triedatum.h @@ -45,13 +45,13 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > TypeTrie tree; Datum* - clone( void ) const + clone( ) const override { return new TrieDatum( *this ); } Datum* - get_ptr() + get_ptr() override { Datum::addReference(); return this; @@ -82,29 +82,29 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > void - print( std::ostream& o ) const + print( std::ostream& o ) const override { o << '+' << name << '+'; } void - pprint( std::ostream& o ) const + pprint( std::ostream& o ) const override { print( o ); } void - info( std::ostream& out ) const + info( std::ostream& out ) const override { pprint( out ); out << "\nVariants are:" << std::endl; tree.info( out ); } - bool equals( Datum const* ) const; + bool equals( Datum const* ) const override; const Name& - getname( void ) const + getname( ) const { return name; } @@ -128,7 +128,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > } TypeTrie& - get( void ) + get( ) { return tree; } @@ -146,7 +146,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > static void operator delete( void* p, size_t size ) { - if ( p == NULL ) + if ( p == nullptr ) { return; } diff --git a/sli/typechk.cc b/sli/typechk.cc index d78b5ae576..49a9301919 100644 --- a/sli/typechk.cc +++ b/sli/typechk.cc @@ -68,18 +68,18 @@ void TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const { assert( a.size() == 0 ); - if ( next == NULL && alt == NULL ) // Leaf node + if ( next == nullptr && alt == nullptr ) // Leaf node { a.push_back( func ); } else { - assert( next != NULL ); + assert( next != nullptr ); a.push_back( LiteralDatum( type ) ); TokenArray a_next; next->toTokenArray( a_next ); a.push_back( ArrayDatum( a_next ) ); - if ( alt != NULL ) + if ( alt != nullptr ) { TokenArray a_alt; alt->toTokenArray( a_alt ); @@ -92,7 +92,7 @@ TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const void TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl ) const { - if ( next == NULL && alt == NULL ) // Leaf node + if ( next == nullptr && alt == nullptr ) // Leaf node { // print type list then function for ( int i = tl.size() - 1; i >= 0; --i ) @@ -103,11 +103,11 @@ TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl } else { - assert( next != NULL ); + assert( next != nullptr ); tl.push_back( this ); next->info( out, tl ); tl.pop_back(); - if ( alt != NULL ) + if ( alt != nullptr ) { alt->info( out, tl ); } @@ -120,7 +120,7 @@ TypeTrie::newnode( const TokenArray& ta ) const { assert( ta.size() > 0 ); assert( ta.size() <= 3 ); - TypeNode* n = NULL; + TypeNode* n = nullptr; if ( ta.size() == 1 ) // leaf { n = new TypeNode( sli::object, ta[ 0 ] ); @@ -130,15 +130,15 @@ TypeTrie::newnode( const TokenArray& ta ) const // first object in the array must be a literal, indicating the type // the second and third object must be an array. LiteralDatum* typed = dynamic_cast< LiteralDatum* >( ta[ 0 ].datum() ); - assert( typed != NULL ); + assert( typed != nullptr ); ArrayDatum* nextd = dynamic_cast< ArrayDatum* >( ta[ 1 ].datum() ); - assert( nextd != NULL ); + assert( nextd != nullptr ); n = new TypeNode( *typed ); n->next = newnode( *nextd ); if ( ta.size() == 3 ) { ArrayDatum* altd = dynamic_cast< ArrayDatum* >( ta[ 2 ].datum() ); - assert( altd != NULL ); + assert( altd != nullptr ); n->alt = newnode( *altd ); } } @@ -173,7 +173,7 @@ TypeTrie::getalternative( TypeTrie::TypeNode* pos, const Name& type ) while ( type != pos->type ) { - if ( pos->alt == NULL ) + if ( pos->alt == nullptr ) { pos->alt = new TypeNode( type ); } @@ -193,7 +193,7 @@ TypeTrie::getalternative( TypeTrie::TypeNode* pos, const Name& type ) new_tail->type = sli::any; new_tail->func.swap( pos->func ); new_tail->next = pos->next; - pos->next = NULL; + pos->next = nullptr; // this while() cycle will terminate, as // pos->type==type by assignment. @@ -235,7 +235,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) TypeNode* pos = root; const Name empty; - assert( root != NULL ); + assert( root != nullptr ); // Functions with no parameters are possible, but useless in trie // structures, so it is best to forbid them! @@ -245,7 +245,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) { pos = getalternative( pos, a[ level ] ); - if ( pos->next == NULL ) + if ( pos->next == nullptr ) { pos->next = new TypeNode( empty ); } @@ -258,7 +258,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) 2. If pos->alt != NULL, something undefined must have happened. This should be impossible. */ - if ( pos->next == NULL ) + if ( pos->next == nullptr ) { pos->type = sli::object; pos->func.move( f ); @@ -280,7 +280,7 @@ void TypeTrie::toTokenArray( TokenArray& a ) const { a.clear(); - if ( root != NULL ) + if ( root != nullptr ) { root->toTokenArray( a ); } @@ -291,7 +291,7 @@ TypeTrie::info( std::ostream& out ) const { std::vector< TypeNode const* > tl; tl.reserve( 5 ); - if ( root != NULL ) + if ( root != nullptr ) { root->info( out, tl ); } diff --git a/sli/typechk.h b/sli/typechk.h index a6214440dd..38e557a814 100644 --- a/sli/typechk.h +++ b/sli/typechk.h @@ -87,13 +87,13 @@ class TypeTrie void - addreference( void ) + addreference( ) { ++refs; } void - removereference( void ) + removereference( ) { if ( --refs == 0 ) { @@ -105,8 +105,8 @@ class TypeTrie : refs( 1 ) , type( n ) , func() - , alt( NULL ) - , next( NULL ) + , alt( nullptr ) + , next( nullptr ) { } @@ -114,18 +114,18 @@ class TypeTrie : refs( 1 ) , type( n ) , func( f ) - , alt( NULL ) - , next( NULL ) + , alt( nullptr ) + , next( nullptr ) { } ~TypeNode() { - if ( next != NULL ) + if ( next != nullptr ) { next->removereference(); } - if ( alt != NULL ) + if ( alt != nullptr ) { alt->removereference(); } @@ -148,7 +148,7 @@ class TypeTrie } TypeTrie( const TokenArray& ta ) - : root( NULL ) + : root( nullptr ) { root = newnode( ta ); } @@ -156,7 +156,7 @@ class TypeTrie TypeTrie( const TypeTrie& tt ) : root( tt.root ) { - if ( root != NULL ) + if ( root != nullptr ) { root->addreference(); } @@ -185,7 +185,7 @@ class TypeTrie inline TypeTrie::~TypeTrie() { - if ( root != NULL ) + if ( root != nullptr ) { root->removereference(); } @@ -233,7 +233,7 @@ TypeTrie::lookup( const TokenStack& st ) const while ( not equals( find_type, pos->type ) ) { - if ( pos->alt != NULL ) + if ( pos->alt != nullptr ) { pos = pos->alt; } diff --git a/sli/utils.cc b/sli/utils.cc index 5853f6b06c..5443aa9818 100644 --- a/sli/utils.cc +++ b/sli/utils.cc @@ -34,7 +34,7 @@ array2vector( std::vector< long >& v, const TokenArray a ) for ( Token* t = a.begin(); t != a.end(); ++t ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( id == NULL ) + if ( id == nullptr ) { status = false; break; diff --git a/testsuite/cpptests/test_enum_bitfield.h b/testsuite/cpptests/test_enum_bitfield.h index 599a80ac47..ac005e2e37 100644 --- a/testsuite/cpptests/test_enum_bitfield.h +++ b/testsuite/cpptests/test_enum_bitfield.h @@ -103,4 +103,4 @@ BOOST_AUTO_TEST_CASE( test_enum_bitfield_ops ) BOOST_AUTO_TEST_SUITE_END() } -#endif /* TEST_SORT_H */ +#endif /* TEST_ENUM_BITFIELD_H */ From 6354bc6de8e37d9aa1799329b1d759c5f9c20ac1 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 22 Sep 2022 15:53:11 +0200 Subject: [PATCH 035/150] Fixed some refactoring issues --- models/multimeter.cpp | 6 +++--- nestkernel/exceptions.h | 2 -- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/models/multimeter.cpp b/models/multimeter.cpp index a00d73e270..3242ac85e6 100644 --- a/models/multimeter.cpp +++ b/models/multimeter.cpp @@ -206,7 +206,7 @@ multimeter::handle( DataLoggingReply& reply ) DataLoggingReply::Container const& info = reply.get_info(); // count records that have been skipped during inactivity - // size_t inactive_skipped = 0; + size_t inactive_skipped = 0; // record all data, time point by time point for ( size_t j = 0; j < info.size(); ++j ) @@ -216,11 +216,11 @@ multimeter::handle( DataLoggingReply& reply ) break; } - /* if ( not is_active( info[ j ].timestamp ) ) + if ( not is_active( info[ j ].timestamp ) ) { ++inactive_skipped; continue; - } */ + } reply.set_stamp( info[ j ].timestamp ); // const index sender = reply.get_sender_node_id(); diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index be5c729025..7ac62d5155 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -652,7 +652,6 @@ class DimensionMismatch : public KernelException : KernelException( "DimensionMismatch" ) , expected_( -1 ) , provided_( -1 ) - , { } @@ -660,7 +659,6 @@ class DimensionMismatch : public KernelException : KernelException( "DimensionMismatch" ) , expected_( expected ) , provided_( provided ) - , { } From bf5e583adaadb84c40620981214ebdb935c5bf98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Tue, 27 Sep 2022 11:02:09 +0200 Subject: [PATCH 036/150] Added test for setting V_m for all relevant node models --- testsuite/pytests/test_nodeParametrization.py | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/testsuite/pytests/test_nodeParametrization.py b/testsuite/pytests/test_nodeParametrization.py index a377730e0d..5d34724c60 100644 --- a/testsuite/pytests/test_nodeParametrization.py +++ b/testsuite/pytests/test_nodeParametrization.py @@ -26,6 +26,7 @@ import nest import numpy as np import unittest +import warnings class TestNodeParametrization(unittest.TestCase): @@ -698,6 +699,31 @@ def test_parameter_apply(self): distance_reference = tuple(np.sqrt(position_array[:, 0]**2 + position_array[:, 1]**2)) self.assertAlmostEqual(distance_reference, nest.spatial.distance.apply(layer[0], positions)) + def test_set_vm(self): + nest.set_verbosity('M_FATAL') + warnings.simplefilter('ignore') # Suppress warnings + failing_models = [] + for m in nest.node_models: + n = nest.Create(m) + try: + n.get('V_m') + except KeyError: + continue + + try: + n.V_m = 0.5 + except nest.NESTError: + failing_models.append(m) + print(f'Constant Failed: {m}') + + try: + n.V_m = nest.random.uniform(0., 1.) + except nest.NESTError: + failing_models.append(m) + print(f'Random Failed : {m}') + + self.assertEqual(failing_models, []) + def suite(): suite = unittest.makeSuite(TestNodeParametrization, 'test') From 4a5650968d4a8aa2e4da0e8b59cd81e82182df44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Tue, 27 Sep 2022 11:03:36 +0200 Subject: [PATCH 037/150] Updated models to take a parameter object where relevant --- models/glif_cond.cpp | 34 ++++++++++++----------- models/glif_cond.h | 12 ++++----- models/glif_psc.cpp | 42 +++++++++++++++-------------- models/glif_psc.h | 12 ++++----- models/hh_cond_beta_gap_traub.cpp | 45 ++++++++++++++++--------------- models/hh_cond_beta_gap_traub.h | 14 +++++----- models/iaf_psc_alpha_canon.cpp | 31 ++++++++++----------- models/iaf_psc_alpha_canon.h | 12 ++++----- models/iaf_psc_alpha_ps.cpp | 27 ++++++++++--------- models/iaf_psc_alpha_ps.h | 12 ++++----- models/iaf_psc_delta_ps.cpp | 23 ++++++++-------- models/iaf_psc_delta_ps.h | 12 ++++----- 12 files changed, 142 insertions(+), 134 deletions(-) diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 0b48ea9253..f858d96368 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -29,6 +29,7 @@ #include // Includes from libnestutil: +#include "dict_util.h" #include "numerics.h" // Includes from nestkernel: @@ -224,7 +225,7 @@ nest::glif_cond::Parameters_::get( DictionaryDatum& d ) const } double -nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) +nest::glif_cond::Parameters_::set( const DictionaryDatum& d, Node* node ) { // if E_L_ is changed, we need to adjust all variables defined relative to // E_L_ @@ -232,7 +233,7 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) updateValue< double >( d, names::E_L, E_L_ ); const double delta_EL = E_L_ - ELold; - if ( updateValue< double >( d, names::V_reset, V_reset_ ) ) + if ( updateValueParam< double >( d, names::V_reset, V_reset_, node ) ) { V_reset_ -= E_L_; } @@ -241,7 +242,7 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) V_reset_ -= delta_EL; } - if ( updateValue< double >( d, names::V_th, th_inf_ ) ) + if ( updateValueParam< double >( d, names::V_th, th_inf_, node ) ) { th_inf_ -= E_L_; } @@ -250,17 +251,17 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) th_inf_ -= delta_EL; } - updateValue< double >( d, names::g_m, G_ ); - updateValue< double >( d, names::C_m, C_m_ ); - updateValue< double >( d, names::t_ref, t_ref_ ); + updateValueParam< double >( d, names::g_m, G_, node ); + updateValueParam< double >( d, names::C_m, C_m_, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); - updateValue< double >( d, names::th_spike_add, th_spike_add_ ); - updateValue< double >( d, names::th_spike_decay, th_spike_decay_ ); - updateValue< double >( d, names::voltage_reset_fraction, voltage_reset_fraction_ ); - updateValue< double >( d, names::voltage_reset_add, voltage_reset_add_ ); + updateValueParam< double >( d, names::th_spike_add, th_spike_add_, node ); + updateValueParam< double >( d, names::th_spike_decay, th_spike_decay_, node ); + updateValueParam< double >( d, names::voltage_reset_fraction, voltage_reset_fraction_, node ); + updateValueParam< double >( d, names::voltage_reset_add, voltage_reset_add_, node ); - updateValue< double >( d, names::th_voltage_index, th_voltage_index_ ); - updateValue< double >( d, names::th_voltage_decay, th_voltage_decay_ ); + updateValueParam< double >( d, names::th_voltage_index, th_voltage_index_, node ); + updateValueParam< double >( d, names::th_voltage_decay, th_voltage_decay_, node ); updateValue< std::vector< double > >( d, names::asc_init, asc_init_ ); updateValue< std::vector< double > >( d, names::asc_decay, asc_decay_ ); @@ -415,9 +416,9 @@ nest::glif_cond::State_::get( DictionaryDatum& d, const Parameters_& p ) const } void -nest::glif_cond::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL ) +nest::glif_cond::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL, Node* node ) { - if ( updateValue< double >( d, names::V_m, y_[ V_M ] ) ) + if ( updateValueParam< double >( d, names::V_m, y_[ V_M ], node ) ) { y_[ V_M ] -= p.E_L_; } @@ -442,12 +443,13 @@ nest::glif_cond::State_::set( const DictionaryDatum& d, const Parameters_& p, do } } - if ( updateValue< double >( d, names::threshold_spike, threshold_spike_ ) and not p.has_theta_spike_ ) + if ( updateValueParam< double >( d, names::threshold_spike, threshold_spike_, node ) and not p.has_theta_spike_ ) { throw BadProperty( "Threshold spike component is not supported or settable in the current model mechanisms." ); } - if ( updateValue< double >( d, names::threshold_voltage, threshold_voltage_ ) and not p.has_theta_voltage_ ) + if ( updateValueParam< double >( d, names::threshold_voltage, threshold_voltage_, node ) + and not p.has_theta_voltage_ ) { throw BadProperty( "Threshold voltage component is not supported or settable in the current model mechanisms." ); } diff --git a/models/glif_cond.h b/models/glif_cond.h index 5d386a30a5..95b95defeb 100644 --- a/models/glif_cond.h +++ b/models/glif_cond.h @@ -277,7 +277,7 @@ class glif_cond : public nest::ArchivingNode Parameters_(); void get( DictionaryDatum& ) const; - double set( const DictionaryDatum& ); + double set( const DictionaryDatum&, Node* ); }; @@ -319,7 +319,7 @@ class glif_cond : public nest::ArchivingNode State_( const Parameters_& ); void get( DictionaryDatum&, const Parameters_& ) const; - void set( const DictionaryDatum&, const Parameters_&, double ); + void set( const DictionaryDatum&, const Parameters_&, double, Node* ); }; @@ -480,10 +480,10 @@ glif_cond::get_status( DictionaryDatum& d ) const inline void glif_cond::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - const double delta_EL = ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp, delta_EL ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + const double delta_EL = ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, delta_EL, this ); // throws if BadProperty ArchivingNode::set_status( d ); diff --git a/models/glif_psc.cpp b/models/glif_psc.cpp index cbe7ddae00..ecb28a5c26 100644 --- a/models/glif_psc.cpp +++ b/models/glif_psc.cpp @@ -27,6 +27,7 @@ #include // Includes from libnestutil: +#include "dict_util.h" #include "numerics.h" #include "propagator_stability.h" @@ -148,15 +149,15 @@ nest::glif_psc::Parameters_::get( DictionaryDatum& d ) const } double -nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) +nest::glif_psc::Parameters_::set( const DictionaryDatum& d, Node* node ) { // if E_L_ is changed, we need to adjust all variables defined relative to // E_L_ const double ELold = E_L_; - updateValue< double >( d, names::E_L, E_L_ ); + updateValueParam< double >( d, names::E_L, E_L_, node ); const double delta_EL = E_L_ - ELold; - if ( updateValue< double >( d, names::V_reset, V_reset_ ) ) + if ( updateValueParam< double >( d, names::V_reset, V_reset_, node ) ) { V_reset_ -= E_L_; } @@ -165,7 +166,7 @@ nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) V_reset_ -= delta_EL; } - if ( updateValue< double >( d, names::V_th, th_inf_ ) ) + if ( updateValueParam< double >( d, names::V_th, th_inf_, node ) ) { th_inf_ -= E_L_; } @@ -174,17 +175,17 @@ nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) th_inf_ -= delta_EL; } - updateValue< double >( d, names::g, G_ ); - updateValue< double >( d, names::C_m, C_m_ ); - updateValue< double >( d, names::t_ref, t_ref_ ); + updateValueParam< double >( d, names::g, G_, node ); + updateValueParam< double >( d, names::C_m, C_m_, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); - updateValue< double >( d, names::th_spike_add, th_spike_add_ ); - updateValue< double >( d, names::th_spike_decay, th_spike_decay_ ); - updateValue< double >( d, names::voltage_reset_fraction, voltage_reset_fraction_ ); - updateValue< double >( d, names::voltage_reset_add, voltage_reset_add_ ); + updateValueParam< double >( d, names::th_spike_add, th_spike_add_, node ); + updateValueParam< double >( d, names::th_spike_decay, th_spike_decay_, node ); + updateValueParam< double >( d, names::voltage_reset_fraction, voltage_reset_fraction_, node ); + updateValueParam< double >( d, names::voltage_reset_add, voltage_reset_add_, node ); - updateValue< double >( d, names::th_voltage_index, th_voltage_index_ ); - updateValue< double >( d, names::th_voltage_decay, th_voltage_decay_ ); + updateValueParam< double >( d, names::th_voltage_index, th_voltage_index_, node ); + updateValueParam< double >( d, names::th_voltage_decay, th_voltage_decay_, node ); updateValue< std::vector< double > >( d, names::asc_init, asc_init_ ); updateValue< std::vector< double > >( d, names::asc_decay, asc_decay_ ); @@ -192,9 +193,9 @@ nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) updateValue< std::vector< double > >( d, names::asc_r, asc_r_ ); // set model mechanisms - updateValue< bool >( d, names::spike_dependent_threshold, has_theta_spike_ ); - updateValue< bool >( d, names::after_spike_currents, has_asc_ ); - updateValue< bool >( d, names::adapting_threshold, has_theta_voltage_ ); + updateValueParam< bool >( d, names::spike_dependent_threshold, has_theta_spike_, node ); + updateValueParam< bool >( d, names::after_spike_currents, has_asc_, node ); + updateValueParam< bool >( d, names::adapting_threshold, has_theta_voltage_, node ); // check model mechanisms parameter if ( not( ( not has_theta_spike_ and not has_asc_ and not has_theta_voltage_ ) or // glif1 @@ -311,9 +312,9 @@ nest::glif_psc::State_::get( DictionaryDatum& d, const Parameters_& p ) const } void -nest::glif_psc::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL ) +nest::glif_psc::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL, Node* node ) { - if ( updateValue< double >( d, names::V_m, U_ ) ) + if ( updateValueParam< double >( d, names::V_m, U_, node ) ) { U_ -= p.E_L_; } @@ -338,12 +339,13 @@ nest::glif_psc::State_::set( const DictionaryDatum& d, const Parameters_& p, dou } } - if ( updateValue< double >( d, names::threshold_spike, threshold_spike_ ) and not p.has_theta_spike_ ) + if ( updateValueParam< double >( d, names::threshold_spike, threshold_spike_, node ) and not p.has_theta_spike_ ) { throw BadProperty( "Threshold spike component is not supported or settable in the current model mechanisms." ); } - if ( updateValue< double >( d, names::threshold_voltage, threshold_voltage_ ) and not p.has_theta_voltage_ ) + if ( updateValueParam< double >( d, names::threshold_voltage, threshold_voltage_, node ) + and not p.has_theta_voltage_ ) { throw BadProperty( "Threshold voltage component is not supported or settable in the current model mechanisms." ); } diff --git a/models/glif_psc.h b/models/glif_psc.h index 551ebc0d16..88bf8a76a6 100644 --- a/models/glif_psc.h +++ b/models/glif_psc.h @@ -267,7 +267,7 @@ class glif_psc : public nest::ArchivingNode Parameters_(); void get( DictionaryDatum& ) const; - double set( const DictionaryDatum& ); + double set( const DictionaryDatum&, Node* ); }; struct State_ @@ -287,7 +287,7 @@ class glif_psc : public nest::ArchivingNode State_( const Parameters_& ); void get( DictionaryDatum&, const Parameters_& ) const; - void set( const DictionaryDatum&, const Parameters_&, double ); + void set( const DictionaryDatum&, const Parameters_&, double, Node* ); }; @@ -433,10 +433,10 @@ glif_psc::get_status( DictionaryDatum& d ) const inline void glif_psc::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - const double delta_EL = ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp, delta_EL ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + const double delta_EL = ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, delta_EL, this ); // throws if BadProperty ArchivingNode::set_status( d ); diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index 97f6a29604..535122733e 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -39,6 +39,7 @@ // Includes from libnestutil: #include "beta_normalization_factor.h" +#include "dict_util.h" #include "numerics.h" // Includes from nestkernel: @@ -249,24 +250,24 @@ nest::hh_cond_beta_gap_traub::Parameters_::get( DictionaryDatum& d ) const } void -nest::hh_cond_beta_gap_traub::Parameters_::set( const DictionaryDatum& d ) +nest::hh_cond_beta_gap_traub::Parameters_::set( const DictionaryDatum& d, Node* node ) { - updateValue< double >( d, names::g_Na, g_Na ); - updateValue< double >( d, names::g_K, g_K ); - updateValue< double >( d, names::g_L, g_L ); - updateValue< double >( d, names::C_m, C_m ); - updateValue< double >( d, names::E_Na, E_Na ); - updateValue< double >( d, names::E_K, E_K ); - updateValue< double >( d, names::E_L, E_L ); - updateValue< double >( d, names::V_T, V_T ); - updateValue< double >( d, names::E_ex, E_ex ); - updateValue< double >( d, names::E_in, E_in ); - updateValue< double >( d, names::tau_rise_ex, tau_rise_ex ); - updateValue< double >( d, names::tau_decay_ex, tau_decay_ex ); - updateValue< double >( d, names::tau_rise_in, tau_rise_in ); - updateValue< double >( d, names::tau_decay_in, tau_decay_in ); - updateValue< double >( d, names::t_ref, t_ref_ ); - updateValue< double >( d, names::I_e, I_e ); + updateValueParam< double >( d, names::g_Na, g_Na, node ); + updateValueParam< double >( d, names::g_K, g_K, node ); + updateValueParam< double >( d, names::g_L, g_L, node ); + updateValueParam< double >( d, names::C_m, C_m, node ); + updateValueParam< double >( d, names::E_Na, E_Na, node ); + updateValueParam< double >( d, names::E_K, E_K, node ); + updateValueParam< double >( d, names::E_L, E_L, node ); + updateValueParam< double >( d, names::V_T, V_T, node ); + updateValueParam< double >( d, names::E_ex, E_ex, node ); + updateValueParam< double >( d, names::E_in, E_in, node ); + updateValueParam< double >( d, names::tau_rise_ex, tau_rise_ex, node ); + updateValueParam< double >( d, names::tau_decay_ex, tau_decay_ex, node ); + updateValueParam< double >( d, names::tau_rise_in, tau_rise_in, node ); + updateValueParam< double >( d, names::tau_decay_in, tau_decay_in, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); + updateValueParam< double >( d, names::I_e, I_e, node ); if ( C_m <= 0 ) { @@ -299,12 +300,12 @@ nest::hh_cond_beta_gap_traub::State_::get( DictionaryDatum& d ) const } void -nest::hh_cond_beta_gap_traub::State_::set( const DictionaryDatum& d, const Parameters_& ) +nest::hh_cond_beta_gap_traub::State_::set( const DictionaryDatum& d, const Parameters_&, Node* node ) { - updateValue< double >( d, names::V_m, y_[ V_M ] ); - updateValue< double >( d, names::Act_m, y_[ HH_M ] ); - updateValue< double >( d, names::Inact_h, y_[ HH_H ] ); - updateValue< double >( d, names::Act_n, y_[ HH_N ] ); + updateValueParam< double >( d, names::V_m, y_[ V_M ], node ); + updateValueParam< double >( d, names::Act_m, y_[ HH_M ], node ); + updateValueParam< double >( d, names::Inact_h, y_[ HH_H ], node ); + updateValueParam< double >( d, names::Act_n, y_[ HH_N ], node ); if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); diff --git a/models/hh_cond_beta_gap_traub.h b/models/hh_cond_beta_gap_traub.h index 7d60f8dd52..ffae0e77d7 100644 --- a/models/hh_cond_beta_gap_traub.h +++ b/models/hh_cond_beta_gap_traub.h @@ -262,8 +262,8 @@ class hh_cond_beta_gap_traub : public ArchivingNode Parameters_(); - void get( DictionaryDatum& ) const; //!< Store current values in dictionary - void set( const DictionaryDatum& ); //!< Set values from dicitonary + void get( DictionaryDatum& ) const; //!< Store current values in dictionary + void set( const DictionaryDatum&, Node* ); //!< Set values from dicitonary }; public: @@ -299,7 +299,7 @@ class hh_cond_beta_gap_traub : public ArchivingNode State_& operator=( const State_& ); void get( DictionaryDatum& ) const; - void set( const DictionaryDatum&, const Parameters_& ); + void set( const DictionaryDatum&, const Parameters_&, Node* ); }; // Variables class ------------------------------------------------------- @@ -480,10 +480,10 @@ hh_cond_beta_gap_traub::get_status( DictionaryDatum& d ) const inline void hh_cond_beta_gap_traub::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, this ); // throws if BadProperty // We now know that (ptmp, stmp) are consistent. We do not // write them back to (P_, S_) before we are also sure that diff --git a/models/iaf_psc_alpha_canon.cpp b/models/iaf_psc_alpha_canon.cpp index 7032a8d32b..78c834608d 100644 --- a/models/iaf_psc_alpha_canon.cpp +++ b/models/iaf_psc_alpha_canon.cpp @@ -26,6 +26,7 @@ #include // Includes from libnestutil: +#include "dict_util.h" #include "numerics.h" #include "propagator_stability.h" @@ -110,21 +111,21 @@ nest::iaf_psc_alpha_canon::Parameters_::get( DictionaryDatum& d ) const } double -nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) +nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d, Node* node ) { // if E_L_ is changed, we need to adjust all variables defined relative to // E_L_ const double ELold = E_L_; - updateValue< double >( d, names::E_L, E_L_ ); + updateValueParam< double >( d, names::E_L, E_L_, node ); const double delta_EL = E_L_ - ELold; - updateValue< double >( d, names::tau_m, tau_m_ ); - updateValue< double >( d, names::tau_syn, tau_syn_ ); - updateValue< double >( d, names::C_m, c_m_ ); - updateValue< double >( d, names::t_ref, t_ref_ ); - updateValue< double >( d, names::I_e, I_e_ ); + updateValueParam< double >( d, names::tau_m, tau_m_, node ); + updateValueParam< double >( d, names::tau_syn, tau_syn_, node ); + updateValueParam< double >( d, names::C_m, c_m_, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); + updateValueParam< double >( d, names::I_e, I_e_, node ); - if ( updateValue< double >( d, names::V_th, U_th_ ) ) + if ( updateValueParam< double >( d, names::V_th, U_th_, node ) ) { U_th_ -= E_L_; } @@ -133,7 +134,7 @@ nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) U_th_ -= delta_EL; } - if ( updateValue< double >( d, names::V_min, U_min_ ) ) + if ( updateValueParam< double >( d, names::V_min, U_min_, node ) ) { U_min_ -= E_L_; } @@ -142,7 +143,7 @@ nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) U_min_ -= delta_EL; } - if ( updateValue< double >( d, names::V_reset, U_reset_ ) ) + if ( updateValueParam< double >( d, names::V_reset, U_reset_, node ) ) { U_reset_ -= E_L_; } @@ -152,7 +153,7 @@ nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) } long tmp; - if ( updateValue< long >( d, names::Interpol_Order, tmp ) ) + if ( updateValueParam< long >( d, names::Interpol_Order, tmp, node ) ) { if ( NO_INTERPOL <= tmp && tmp < END_INTERP_ORDER ) { @@ -200,9 +201,9 @@ nest::iaf_psc_alpha_canon::State_::get( DictionaryDatum& d, const Parameters_& p } void -nest::iaf_psc_alpha_canon::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL ) +nest::iaf_psc_alpha_canon::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL, Node* node ) { - if ( updateValue< double >( d, names::V_m, y3_ ) ) + if ( updateValueParam< double >( d, names::V_m, y3_, node ) ) { y3_ -= p.E_L_; } @@ -211,8 +212,8 @@ nest::iaf_psc_alpha_canon::State_::set( const DictionaryDatum& d, const Paramete y3_ -= delta_EL; } - updateValue< double >( d, names::y1, y1_ ); - updateValue< double >( d, names::y2, y2_ ); + updateValueParam< double >( d, names::y1, y1_, node ); + updateValueParam< double >( d, names::y2, y2_, node ); } nest::iaf_psc_alpha_canon::Buffers_::Buffers_( iaf_psc_alpha_canon& n ) diff --git a/models/iaf_psc_alpha_canon.h b/models/iaf_psc_alpha_canon.h index 525c9b2294..cc9eca2f29 100644 --- a/models/iaf_psc_alpha_canon.h +++ b/models/iaf_psc_alpha_canon.h @@ -351,7 +351,7 @@ class iaf_psc_alpha_canon : public ArchivingNode /** Set values from dictionary. * @returns Change in reversal potential E_L, to be passed to State_::set() */ - double set( const DictionaryDatum& ); + double set( const DictionaryDatum&, Node* ); }; // ---------------------------------------------------------------- @@ -378,7 +378,7 @@ class iaf_psc_alpha_canon : public ArchivingNode * @param current parameters * @param Change in reversal potential E_L specified by this dict */ - void set( const DictionaryDatum&, const Parameters_&, double ); + void set( const DictionaryDatum&, const Parameters_&, double, Node* ); }; // ---------------------------------------------------------------- @@ -517,10 +517,10 @@ iaf_psc_alpha_canon::get_status( DictionaryDatum& d ) const inline void iaf_psc_alpha_canon::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - const double delta_EL = ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp, delta_EL ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + const double delta_EL = ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, delta_EL, this ); // throws if BadProperty // We now know that (ptmp, stmp) are consistent. We do not // write them back to (P_, S_) before we are also sure that diff --git a/models/iaf_psc_alpha_ps.cpp b/models/iaf_psc_alpha_ps.cpp index be1f8b8076..63fc289cbd 100644 --- a/models/iaf_psc_alpha_ps.cpp +++ b/models/iaf_psc_alpha_ps.cpp @@ -26,6 +26,7 @@ #include // Includes from libnestutil: +#include "dict_util.h" #include "numerics.h" #include "propagator_stability.h" #include "regula_falsi.h" @@ -115,22 +116,22 @@ nest::iaf_psc_alpha_ps::Parameters_::get( DictionaryDatum& d ) const } double -nest::iaf_psc_alpha_ps::Parameters_::set( const DictionaryDatum& d ) +nest::iaf_psc_alpha_ps::Parameters_::set( const DictionaryDatum& d, Node* node ) { // if E_L_ is changed, we need to adjust all variables defined relative to // E_L_ const double ELold = E_L_; - updateValue< double >( d, names::E_L, E_L_ ); + updateValueParam< double >( d, names::E_L, E_L_, node ); const double delta_EL = E_L_ - ELold; - updateValue< double >( d, names::tau_m, tau_m_ ); - updateValue< double >( d, names::tau_syn_ex, tau_syn_ex_ ); - updateValue< double >( d, names::tau_syn_in, tau_syn_in_ ); - updateValue< double >( d, names::C_m, c_m_ ); - updateValue< double >( d, names::t_ref, t_ref_ ); - updateValue< double >( d, names::I_e, I_e_ ); + updateValueParam< double >( d, names::tau_m, tau_m_, node ); + updateValueParam< double >( d, names::tau_syn_ex, tau_syn_ex_, node ); + updateValueParam< double >( d, names::tau_syn_in, tau_syn_in_, node ); + updateValueParam< double >( d, names::C_m, c_m_, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); + updateValueParam< double >( d, names::I_e, I_e_, node ); - if ( updateValue< double >( d, names::V_th, U_th_ ) ) + if ( updateValueParam< double >( d, names::V_th, U_th_, node ) ) { U_th_ -= E_L_; } @@ -139,7 +140,7 @@ nest::iaf_psc_alpha_ps::Parameters_::set( const DictionaryDatum& d ) U_th_ -= delta_EL; } - if ( updateValue< double >( d, names::V_min, U_min_ ) ) + if ( updateValueParam< double >( d, names::V_min, U_min_, node ) ) { U_min_ -= E_L_; } @@ -148,7 +149,7 @@ nest::iaf_psc_alpha_ps::Parameters_::set( const DictionaryDatum& d ) U_min_ -= delta_EL; } - if ( updateValue< double >( d, names::V_reset, U_reset_ ) ) + if ( updateValueParam< double >( d, names::V_reset, U_reset_, node ) ) { U_reset_ -= E_L_; } @@ -197,9 +198,9 @@ nest::iaf_psc_alpha_ps::State_::get( DictionaryDatum& d, const Parameters_& p ) } void -nest::iaf_psc_alpha_ps::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL ) +nest::iaf_psc_alpha_ps::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL, Node* node ) { - if ( updateValue< double >( d, names::V_m, V_m_ ) ) + if ( updateValueParam< double >( d, names::V_m, V_m_, node ) ) { V_m_ -= p.E_L_; } diff --git a/models/iaf_psc_alpha_ps.h b/models/iaf_psc_alpha_ps.h index 9747f18dfe..a54bc0a2a4 100644 --- a/models/iaf_psc_alpha_ps.h +++ b/models/iaf_psc_alpha_ps.h @@ -317,7 +317,7 @@ class iaf_psc_alpha_ps : public ArchivingNode /** Set values from dictionary. * @returns Change in reversal potential E_L, to be passed to State_::set() */ - double set( const DictionaryDatum& ); + double set( const DictionaryDatum&, Node* ); }; // ---------------------------------------------------------------- @@ -346,7 +346,7 @@ class iaf_psc_alpha_ps : public ArchivingNode * @param current parameters * @param Change in reversal potential E_L specified by this dict */ - void set( const DictionaryDatum&, const Parameters_&, double ); + void set( const DictionaryDatum&, const Parameters_&, double, Node* ); }; // ---------------------------------------------------------------- @@ -504,10 +504,10 @@ iaf_psc_alpha_ps::get_status( DictionaryDatum& d ) const inline void iaf_psc_alpha_ps::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - const double delta_EL = ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp, delta_EL ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + const double delta_EL = ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, delta_EL, this ); // throws if BadProperty // We now know that (ptmp, stmp) are consistent. We do not // write them back to (P_, S_) before we are also sure that diff --git a/models/iaf_psc_delta_ps.cpp b/models/iaf_psc_delta_ps.cpp index 152486f1e4..12bd52cb18 100644 --- a/models/iaf_psc_delta_ps.cpp +++ b/models/iaf_psc_delta_ps.cpp @@ -29,6 +29,7 @@ #include // Includes from libnestutil: +#include "dict_util.h" #include "numerics.h" // Includes from nestkernel: @@ -106,20 +107,20 @@ nest::iaf_psc_delta_ps::Parameters_::get( DictionaryDatum& d ) const } double -nest::iaf_psc_delta_ps::Parameters_::set( const DictionaryDatum& d ) +nest::iaf_psc_delta_ps::Parameters_::set( const DictionaryDatum& d, Node* node ) { // if E_L_ is changed, we need to adjust all variables defined relative to // E_L_ const double ELold = E_L_; - updateValue< double >( d, names::E_L, E_L_ ); + updateValueParam< double >( d, names::E_L, E_L_, node ); const double delta_EL = E_L_ - ELold; - updateValue< double >( d, names::tau_m, tau_m_ ); - updateValue< double >( d, names::C_m, c_m_ ); - updateValue< double >( d, names::t_ref, t_ref_ ); - updateValue< double >( d, names::I_e, I_e_ ); + updateValueParam< double >( d, names::tau_m, tau_m_, node ); + updateValueParam< double >( d, names::C_m, c_m_, node ); + updateValueParam< double >( d, names::t_ref, t_ref_, node ); + updateValueParam< double >( d, names::I_e, I_e_, node ); - if ( updateValue< double >( d, names::V_th, U_th_ ) ) + if ( updateValueParam< double >( d, names::V_th, U_th_, node ) ) { U_th_ -= E_L_; } @@ -128,7 +129,7 @@ nest::iaf_psc_delta_ps::Parameters_::set( const DictionaryDatum& d ) U_th_ -= delta_EL; } - if ( updateValue< double >( d, names::V_min, U_min_ ) ) + if ( updateValueParam< double >( d, names::V_min, U_min_, node ) ) { U_min_ -= E_L_; } @@ -137,7 +138,7 @@ nest::iaf_psc_delta_ps::Parameters_::set( const DictionaryDatum& d ) U_min_ -= delta_EL; } - if ( updateValue< double >( d, names::V_reset, U_reset_ ) ) + if ( updateValueParam< double >( d, names::V_reset, U_reset_, node ) ) { U_reset_ -= E_L_; } @@ -179,9 +180,9 @@ nest::iaf_psc_delta_ps::State_::get( DictionaryDatum& d, const Parameters_& p ) } void -nest::iaf_psc_delta_ps::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL ) +nest::iaf_psc_delta_ps::State_::set( const DictionaryDatum& d, const Parameters_& p, double delta_EL, Node* node ) { - if ( updateValue< double >( d, names::V_m, U_ ) ) + if ( updateValueParam< double >( d, names::V_m, U_, node ) ) { U_ -= p.E_L_; } diff --git a/models/iaf_psc_delta_ps.h b/models/iaf_psc_delta_ps.h index 3c4644fd3a..a492683199 100644 --- a/models/iaf_psc_delta_ps.h +++ b/models/iaf_psc_delta_ps.h @@ -282,7 +282,7 @@ class iaf_psc_delta_ps : public ArchivingNode /** Set values from dictionary. * @returns Change in reversal potential E_L, to be passed to State_::set() */ - double set( const DictionaryDatum& ); + double set( const DictionaryDatum&, Node* ); }; @@ -319,7 +319,7 @@ class iaf_psc_delta_ps : public ArchivingNode * @param current parameters * @param Change in reversal potential E_L specified by this dict */ - void set( const DictionaryDatum&, const Parameters_&, double ); + void set( const DictionaryDatum&, const Parameters_&, double, Node* ); }; // ---------------------------------------------------------------- @@ -449,10 +449,10 @@ iaf_psc_delta_ps::get_status( DictionaryDatum& d ) const inline void iaf_psc_delta_ps::set_status( const DictionaryDatum& d ) { - Parameters_ ptmp = P_; // temporary copy in case of errors - const double delta_EL = ptmp.set( d ); // throws if BadProperty - State_ stmp = S_; // temporary copy in case of errors - stmp.set( d, ptmp, delta_EL ); // throws if BadProperty + Parameters_ ptmp = P_; // temporary copy in case of errors + const double delta_EL = ptmp.set( d, this ); // throws if BadProperty + State_ stmp = S_; // temporary copy in case of errors + stmp.set( d, ptmp, delta_EL, this ); // throws if BadProperty // We now know that (ptmp, stmp) are consistent. We do not // write them back to (P_, S_) before we are also sure that From c7a748db1dc9cdc2827d8a62aec9ac6b975b9672 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Wed, 28 Sep 2022 11:10:38 +0200 Subject: [PATCH 038/150] Moved regression test to its own file --- testsuite/pytests/test_nodeParametrization.py | 25 ---------- .../pytests/test_regression_issue-2480.py | 48 +++++++++++++++++++ 2 files changed, 48 insertions(+), 25 deletions(-) create mode 100644 testsuite/pytests/test_regression_issue-2480.py diff --git a/testsuite/pytests/test_nodeParametrization.py b/testsuite/pytests/test_nodeParametrization.py index 5d34724c60..dafbcd7d83 100644 --- a/testsuite/pytests/test_nodeParametrization.py +++ b/testsuite/pytests/test_nodeParametrization.py @@ -699,31 +699,6 @@ def test_parameter_apply(self): distance_reference = tuple(np.sqrt(position_array[:, 0]**2 + position_array[:, 1]**2)) self.assertAlmostEqual(distance_reference, nest.spatial.distance.apply(layer[0], positions)) - def test_set_vm(self): - nest.set_verbosity('M_FATAL') - warnings.simplefilter('ignore') # Suppress warnings - failing_models = [] - for m in nest.node_models: - n = nest.Create(m) - try: - n.get('V_m') - except KeyError: - continue - - try: - n.V_m = 0.5 - except nest.NESTError: - failing_models.append(m) - print(f'Constant Failed: {m}') - - try: - n.V_m = nest.random.uniform(0., 1.) - except nest.NESTError: - failing_models.append(m) - print(f'Random Failed : {m}') - - self.assertEqual(failing_models, []) - def suite(): suite = unittest.makeSuite(TestNodeParametrization, 'test') diff --git a/testsuite/pytests/test_regression_issue-2480.py b/testsuite/pytests/test_regression_issue-2480.py new file mode 100644 index 0000000000..c6c7f2894e --- /dev/null +++ b/testsuite/pytests/test_regression_issue-2480.py @@ -0,0 +1,48 @@ + + +# -*- coding: utf-8 -*- +# +# test_regression_issue-2480.py +# +# 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 . + +import nest +import pytest +import warnings + + +@pytest.fixture(autouse=True) +def reset(): + nest.ResetKernel() + + +@pytest.mark.parametrize("model", [m for m in nest.node_models if 'V_m' in nest.GetDefaults(m)]) +def test_set_vm(model): + nest.set_verbosity('M_FATAL') + warnings.simplefilter('ignore') # Suppress warnings + n = nest.Create(model) + + try: + n.V_m = 0.5 + except nest.NESTError as e: + assert False, f'Setting a V_m with a constant raises {e}' + + try: + n.V_m = nest.random.uniform(0., 1.) + except nest.NESTError as e: + assert False, f'Setting a V_m with a parameter raises {e}' From ad52b5859fb2b9c3582b1b0bf955197593167116 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20M=C3=B8rk?= Date: Wed, 28 Sep 2022 11:38:36 +0200 Subject: [PATCH 039/150] Fixed copyright header --- testsuite/pytests/test_regression_issue-2480.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/testsuite/pytests/test_regression_issue-2480.py b/testsuite/pytests/test_regression_issue-2480.py index c6c7f2894e..c4428a1bff 100644 --- a/testsuite/pytests/test_regression_issue-2480.py +++ b/testsuite/pytests/test_regression_issue-2480.py @@ -1,5 +1,3 @@ - - # -*- coding: utf-8 -*- # # test_regression_issue-2480.py From 796076d4b6cb18e144e971ee8bc9a38b4fbc684f Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 14:42:25 +0200 Subject: [PATCH 040/150] Add element_type metadata entry for recording backends and synapse models --- nestkernel/io_manager.cpp | 1 + nestkernel/model_manager.cpp | 1 + 2 files changed, 2 insertions(+) diff --git a/nestkernel/io_manager.cpp b/nestkernel/io_manager.cpp index 714c1d3e40..3d45b3e2eb 100644 --- a/nestkernel/io_manager.cpp +++ b/nestkernel/io_manager.cpp @@ -198,6 +198,7 @@ IOManager::get_recording_backend_status( std::string recording_backend ) { DictionaryDatum status( new Dictionary ); recording_backends_[ recording_backend ]->get_status( status ); + ( *status )[ names::element_type ] = "recording_backend"; return status; } diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 1bb0fb811e..7249e7e651 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -419,6 +419,7 @@ ModelManager::get_connector_defaults( synindex syn_id ) const } ( *dict )[ names::num_connections ] = kernel().connection_manager.get_num_connections( syn_id ); + ( *dict )[ names::element_type ] = "synapse"; return dict; } From a39941424aa1a288c40927a0637484567c4ce25c Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:02:08 +0200 Subject: [PATCH 041/150] Reorder and clean up registration function for node models --- nestkernel/model_manager.cpp | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 7249e7e651..afe613ac25 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -216,27 +216,24 @@ index ModelManager::register_node_model_( Model* model ) { const index id = node_models_.size(); + const std::string name = model->get_name(); + model->set_model_id( id ); model->set_type_id( id ); - - std::string name = model->get_name(); - builtin_node_models_.push_back( model ); Model* cloned_model = model->clone( name ); cloned_model->set_model_id( id ); - node_models_.push_back( cloned_model ); + modeldict_->insert( name, id ); + #pragma omp parallel { const thread t = kernel().vp_manager.get_thread_id(); - const int model_id = model->get_model_id(); - proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); + proxy_nodes_[ t ].push_back( create_proxynode_( t, id ) ); } - modeldict_->insert( name, id ); - return id; } From aad683d1ecf717f068812de2362d65edacde893e Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:03:04 +0200 Subject: [PATCH 042/150] Reorder and clean up copy function for node models --- nestkernel/model_manager.cpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index afe613ac25..b92c600f2f 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -244,19 +244,16 @@ ModelManager::copy_node_model_( index old_id, Name new_name ) old_model->deprecation_warning( "CopyModel" ); Model* new_model = old_model->clone( new_name.toString() ); - node_models_.push_back( new_model ); - - index new_id = node_models_.size() - 1; + const index new_id = node_models_.size(); new_model->set_model_id( new_id ); + node_models_.push_back( new_model ); modeldict_->insert( new_name, new_id ); #pragma omp parallel { const thread t = kernel().vp_manager.get_thread_id(); - const int model_id = new_model->get_model_id(); - - proxy_nodes_[ t ].push_back( create_proxynode_( t, model_id ) ); + proxy_nodes_[ t ].push_back( create_proxynode_( t, new_id ) ); } return new_id; From fb76daadb12013eb12ebe8d7e289ca217b56a0e3 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:10:29 +0200 Subject: [PATCH 043/150] Simplify and unify test setup --- testsuite/pytests/test_copied_model.py | 65 +++++++++++--------------- 1 file changed, 27 insertions(+), 38 deletions(-) diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copied_model.py index f96581c10d..7d2a25c7b5 100644 --- a/testsuite/pytests/test_copied_model.py +++ b/testsuite/pytests/test_copied_model.py @@ -32,51 +32,40 @@ class CopyModelTestCase(unittest.TestCase): """nest.CopyModel Test""" - def check_copied_model(self, original_model, is_synapse=False): - """Test if the new copied neuron or synapse model has been assigned a correct ID - and if the new name is correctly stored in the new instances.""" + def test_builtin_models(self): + """Check the correctness of the nest.CopyModel on all built-in models""" - keys_to_query = ["model", "model_id"] - if is_synapse: - keys_to_query = ["synapse_model", "synapse_modelid"] + for model in nest.node_models + nest.synapse_models: + self.check_copied_model(model) - new_name = f"{original_model}_copy" - current_model_id = nest.GetDefaults(original_model)[keys_to_query[1]] - - nest.CopyModel(original_model, new_name) - copied_model_new_id = nest.GetDefaults(new_name)[keys_to_query[1]] - - self.assertGreater(copied_model_new_id, current_model_id) - - if not is_synapse: - original_model_instance = nest.Create(original_model) - copied_model_instance = nest.Create(new_name) + def check_copied_model_ids(self, original_model): + """Test if copied models get correct model IDs""" - original_model_info = original_model_instance.get(keys_to_query) + model_type = nest.GetDefaults(original_model, "element_type") - copied_model_info = copied_model_instance.get(keys_to_query) + model_name_key = "model" + model_id_key = "model_id" + if model_type == "synapse": + model_name_key = "synapse_model" + model_id_key = "synapse_modelid" - self.assertNotEqual(copied_model_info[keys_to_query[0]], - original_model_info[keys_to_query[0]]) + original_model_id = nest.GetDefaults(original_model)[model_id_key] - self.assertNotEqual(original_model_info[keys_to_query[0]], "UnknownNode") - - self.assertGreater(copied_model_info[keys_to_query[1]], original_model_info[keys_to_query[1]]) - - def check_copy_model_correctness(self, models, synapse=False): - """Iterates over all registered and available model - and checks the correctness of the nest.CopyModel on each model.""" + new_name = f"{original_model}_copy" + nest.CopyModel(original_model, new_name) + copied_model_id = nest.GetDefaults(new_name)[model_id_key] - for model in models: - self.check_copied_model(model, is_synapse=synapse) + self.assertGreater(copied_model_id, original_model_id) - def test_builtin_neuron_models(self): - """Checks the correctness of the nest.CopyModel on neurons only""" + if model_type == "neuron": + original_model_instance = nest.Create(original_model) + copied_model_instance = nest.Create(new_name) - neurons = nest.node_models - self.check_copy_model_correctness(neurons, synapse=False) + original_model_name = original_model_instance.get(model_name_key) + copied_model_name = copied_model_instance.get(model_name_key) + self.assertNotEqual(original_model_name, copied_model_name) + self.assertNotEqual(copied_model_name, "UnknownNode") - def test_builtin_synapse_models(self): - """Checks the correctness of the nest.CopyModel on synapses only""" - synapses = nest.synapse_models - self.check_copy_model_correctness(synapses, synapse=True) + original_model_id = original_model_instance.get(model_id_key) + copied_model_id = copied_model_instance.get(model_id_key) + self.assertGreater(copied_model_id, original_model_id) From 603835ce1b599e450934a41e66737a5609741451 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:11:16 +0200 Subject: [PATCH 044/150] Move test for CopyModel to a more logical location --- testsuite/pytests/test_copied_model.py | 20 ++++++++++++++++++++ testsuite/pytests/test_create.py | 20 -------------------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copied_model.py index 7d2a25c7b5..86f09abf7c 100644 --- a/testsuite/pytests/test_copied_model.py +++ b/testsuite/pytests/test_copied_model.py @@ -69,3 +69,23 @@ def check_copied_model_ids(self, original_model): original_model_id = original_model_instance.get(model_id_key) copied_model_id = copied_model_instance.get(model_id_key) self.assertGreater(copied_model_id, original_model_id) + + def test_CopyModel(self): + """Test CopyModel""" + + nest.CopyModel('iaf_psc_alpha', 'new_neuron', {'V_m': 10.0}) + vm = nest.GetDefaults('new_neuron')['V_m'] + self.assertEqual(vm, 10.0) + + n = nest.Create('new_neuron', 10) + vm = nest.GetStatus(n[0])[0]['V_m'] + self.assertEqual(vm, 10.0) + + nest.CopyModel('static_synapse', 'new_synapse', {'weight': 10.}) + nest.Connect(n[0], n[1], syn_spec='new_synapse') + w = nest.GetDefaults('new_synapse')['weight'] + self.assertEqual(w, 10.0) + + self.assertRaisesRegex( + nest.kernel.NESTError, "NewModelNameExists", + nest.CopyModel, 'iaf_psc_alpha', 'new_neuron') diff --git a/testsuite/pytests/test_create.py b/testsuite/pytests/test_create.py index 972efb4e4b..c1ef297ca0 100644 --- a/testsuite/pytests/test_create.py +++ b/testsuite/pytests/test_create.py @@ -84,26 +84,6 @@ def test_ModelDicts(self): self.assertEqual(nest.GetStatus(n, 'V_m'), V_m) - def test_CopyModel(self): - """CopyModel""" - - nest.CopyModel('iaf_psc_alpha', 'new_neuron', {'V_m': 10.0}) - vm = nest.GetDefaults('new_neuron')['V_m'] - self.assertEqual(vm, 10.0) - - n = nest.Create('new_neuron', 10) - vm = nest.GetStatus(n[0])[0]['V_m'] - self.assertEqual(vm, 10.0) - - nest.CopyModel('static_synapse', 'new_synapse', {'weight': 10.}) - nest.Connect(n[0], n[1], syn_spec='new_synapse') - w = nest.GetDefaults('new_synapse')['weight'] - self.assertEqual(w, 10.0) - - self.assertRaisesRegex( - nest.kernel.NESTError, "NewModelNameExists", - nest.CopyModel, 'iaf_psc_alpha', 'new_neuron') - def suite(): suite = unittest.makeSuite(CreateTestCase, 'test') From 4a9042a2bfc0066dfdccf35ba930fe55a82e0cb2 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:11:48 +0200 Subject: [PATCH 045/150] Rename file to be more consistent with other test files --- testsuite/pytests/{test_copied_model.py => test_copy_model.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename testsuite/pytests/{test_copied_model.py => test_copy_model.py} (100%) diff --git a/testsuite/pytests/test_copied_model.py b/testsuite/pytests/test_copy_model.py similarity index 100% rename from testsuite/pytests/test_copied_model.py rename to testsuite/pytests/test_copy_model.py From 8f97502ce359b1284b60fed94d5bde96e3a1c04f Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 28 Sep 2022 23:19:42 +0200 Subject: [PATCH 046/150] Fix copyright header --- testsuite/pytests/test_copy_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testsuite/pytests/test_copy_model.py b/testsuite/pytests/test_copy_model.py index 86f09abf7c..22a2ee22da 100644 --- a/testsuite/pytests/test_copy_model.py +++ b/testsuite/pytests/test_copy_model.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# test_copied_model.py +# test_copy_model.py # # This file is part of NEST. # From f3b25973318930a7eacdfe13236f4dfd1dd4c6e3 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Thu, 29 Sep 2022 00:07:19 +0200 Subject: [PATCH 047/150] Fix oversight --- testsuite/pytests/test_copy_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testsuite/pytests/test_copy_model.py b/testsuite/pytests/test_copy_model.py index 22a2ee22da..eb5406628a 100644 --- a/testsuite/pytests/test_copy_model.py +++ b/testsuite/pytests/test_copy_model.py @@ -36,7 +36,7 @@ def test_builtin_models(self): """Check the correctness of the nest.CopyModel on all built-in models""" for model in nest.node_models + nest.synapse_models: - self.check_copied_model(model) + self.check_copied_model_ids(model) def check_copied_model_ids(self, original_model): """Test if copied models get correct model IDs""" From 574f82761a3fce3aa479598331bb13fc82004aeb Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 29 Sep 2022 15:46:46 +0200 Subject: [PATCH 048/150] Added overrides --- models/hh_cond_beta_gap_traub.h | 4 ++-- models/hh_psc_alpha_gap.h | 2 +- nestkernel/connector_model_impl.h | 2 +- nestkernel/event.h | 8 ++++---- nestkernel/layer.h | 4 ++-- nestkernel/static_assert.h | 2 +- nestkernel/vp_manager.h | 8 ++++---- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/models/hh_cond_beta_gap_traub.h b/models/hh_cond_beta_gap_traub.h index ea4d42d329..35199903fd 100644 --- a/models/hh_cond_beta_gap_traub.h +++ b/models/hh_cond_beta_gap_traub.h @@ -221,8 +221,8 @@ class hh_cond_beta_gap_traub : public ArchivingNode */ bool update_( Time const&, const long, const long, const bool ); - void update( Time const&, const long, const long ); - bool wfr_update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; + bool wfr_update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/hh_psc_alpha_gap.h b/models/hh_psc_alpha_gap.h index 6bf15259c2..f7c4e3d54f 100644 --- a/models/hh_psc_alpha_gap.h +++ b/models/hh_psc_alpha_gap.h @@ -199,7 +199,7 @@ class hh_psc_alpha_gap : public ArchivingNode bool update_( Time const&, const long, const long, const bool ); void update( Time const&, const long, const long ) override; - bool wfr_update( Time const&, const long, const long ); + bool wfr_update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/nestkernel/connector_model_impl.h b/nestkernel/connector_model_impl.h index 7f5ef98f26..544e22b768 100644 --- a/nestkernel/connector_model_impl.h +++ b/nestkernel/connector_model_impl.h @@ -47,7 +47,7 @@ namespace nest // standard implementation to obtain the default delay, assuming that it // is located in GenericConnectorModel::default_connection // synapse types with homogeneous delays must provide a specialization -// that returns the default delay from CommonProperties (or from else where) +// that returns the default delay from CommonProperties (or from else where) // template // double get_default_delay(const GenericConnectorModel &cm) // { diff --git a/nestkernel/event.h b/nestkernel/event.h index b4fe5b7727..a2873a1f9f 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -451,7 +451,7 @@ WeightRecorderEvent::set_receiver_node_id( index node_id ) } inline index -WeightRecorderEvent::get_receiver_node_id( ) const +WeightRecorderEvent::get_receiver_node_id() const { return receiver_node_id_; } @@ -1319,19 +1319,19 @@ Event::set_sender_node_id_info( const thread tid, const synindex syn_id, const i } inline Node& -Event::get_receiver( ) const +Event::get_receiver() const { return *receiver_; } inline Node& -Event::get_sender( ) const +Event::get_sender() const { return *sender_; } inline index -Event::get_sender_node_id( ) const +Event::get_sender_node_id() const { assert( sender_node_id_ > 0 ); return sender_node_id_; diff --git a/nestkernel/layer.h b/nestkernel/layer.h index 9a090a9c63..e9807121a0 100644 --- a/nestkernel/layer.h +++ b/nestkernel/layer.h @@ -306,10 +306,10 @@ class Layer : public AbstractLayer * @param to_pos position to which displacement is to be computed * @returns vector pointing from from_pos to to_pos */ - virtual Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const; + virtual Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const override; virtual double compute_displacement( const std::vector< double >& from_pos, const std::vector< double >& to_pos, - const unsigned int dimension ) const; + const unsigned int dimension ) const override; /** * Returns displacement of node from given position. When using periodic diff --git a/nestkernel/static_assert.h b/nestkernel/static_assert.h index b871ac39c2..7e92d6d0d6 100644 --- a/nestkernel/static_assert.h +++ b/nestkernel/static_assert.h @@ -36,7 +36,7 @@ namespace nest * or * * \code - * typedef StaticAssert::sucess unique-type-name; + * typedef StaticAssert::success unique-type-name; * \endcode * * Allows compilation if the bool-test is true. If bool-test is false, diff --git a/nestkernel/vp_manager.h b/nestkernel/vp_manager.h index 0265c81381..b526778a74 100644 --- a/nestkernel/vp_manager.h +++ b/nestkernel/vp_manager.h @@ -56,11 +56,11 @@ class VPManager : public ManagerInterface { } - virtual void initialize(); - virtual void finalize(); + virtual void initialize() override; + virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ); - virtual void get_status( DictionaryDatum& ); + virtual void set_status( const DictionaryDatum& ) override; + virtual void get_status( DictionaryDatum& ) override; /** * Gets ID of local thread. From 186379120ee7e01ffaf8b62b6ee62c622a7e22f2 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 29 Sep 2022 15:54:43 +0200 Subject: [PATCH 049/150] Fixed formatting --- nestkernel/layer.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nestkernel/layer.h b/nestkernel/layer.h index e9807121a0..ebe98bd3e7 100644 --- a/nestkernel/layer.h +++ b/nestkernel/layer.h @@ -306,8 +306,8 @@ class Layer : public AbstractLayer * @param to_pos position to which displacement is to be computed * @returns vector pointing from from_pos to to_pos */ - virtual Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const override; - virtual double compute_displacement( const std::vector< double >& from_pos, + Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const override; + double compute_displacement( const std::vector< double >& from_pos, const std::vector< double >& to_pos, const unsigned int dimension ) const override; From 99989c1266ec1a735a6dcc0817751991ee467f21 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 29 Sep 2022 16:13:14 +0200 Subject: [PATCH 050/150] Fixed wrong override --- nestkernel/layer.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/layer.h b/nestkernel/layer.h index ebe98bd3e7..21480f2cf8 100644 --- a/nestkernel/layer.h +++ b/nestkernel/layer.h @@ -306,7 +306,7 @@ class Layer : public AbstractLayer * @param to_pos position to which displacement is to be computed * @returns vector pointing from from_pos to to_pos */ - Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const override; + Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const; double compute_displacement( const std::vector< double >& from_pos, const std::vector< double >& to_pos, const unsigned int dimension ) const override; From 96620fe9d6f80dcc0b94a17fbe6bd2d52ff06049 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Fri, 30 Sep 2022 10:18:08 +0200 Subject: [PATCH 051/150] Delete versionchecker.py ...which was created automatically by some script and was not supposed to be committed. --- pynest/nest/versionchecker.py | 33 --------------------------------- 1 file changed, 33 deletions(-) delete mode 100644 pynest/nest/versionchecker.py diff --git a/pynest/nest/versionchecker.py b/pynest/nest/versionchecker.py deleted file mode 100644 index 3bb35f14b9..0000000000 --- a/pynest/nest/versionchecker.py +++ /dev/null @@ -1,33 +0,0 @@ -# -*- coding: utf-8 -*- -# -# versionchecker.py -# -# 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 . - - -""" -Check that the Python compiletime and runtime versions match. - -""" - -v_major_mismatch = sys.version_info.major != 3 -v_minor_mismatch = sys.version_info.minor != 10 -if v_major_mismatch or v_minor_mismatch: - msg = ("Python runtime version does not match 'nest' compiletime version. " - + "Please use Python 3.10.") - raise Exception(msg) From 220cba4b8b651331fe5fcf9bf064726844c82915 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 11:32:47 +0200 Subject: [PATCH 052/150] Applied clang formatting on all .cpp and .h files --- libnestutil/lockptr.h | 28 ++++++++++++++-------------- models/modelsmodule.cpp | 2 +- nestkernel/connector_base.h | 7 +++++-- nestkernel/dynamicloader.cpp | 4 ++-- nestkernel/dynamicloader.h | 4 ++-- nestkernel/growth_curve.h | 9 ++++++--- nestkernel/model.cpp | 2 +- nestkernel/model.h | 4 ++-- nestkernel/music_manager.cpp | 4 ++-- nestkernel/nestmodule.cpp | 8 ++++---- nestkernel/nestmodule.h | 4 ++-- nestkernel/position.h | 2 +- sli/allocator.cpp | 2 +- sli/allocator.h | 10 +++++----- sli/datum.h | 6 +++--- sli/dict.h | 2 +- sli/dictstack.h | 2 +- sli/filesystem.h | 6 +++--- sli/genericdatum.h | 6 +++--- sli/interpret.h | 28 ++++++++++++++-------------- sli/lockptrdatum.h | 2 +- sli/namedatum.h | 4 ++-- sli/numericdatum.h | 2 +- sli/parser.h | 4 ++-- sli/parserdatum.h | 4 ++-- sli/processes.h | 8 ++++---- sli/scanner.h | 2 +- sli/sharedptrdatum.h | 2 +- sli/sliarray.h | 4 ++-- sli/specialfunctionsmodule.h | 8 ++++---- sli/symboldatum.h | 2 +- sli/token.h | 10 +++++----- sli/tokenarray.h | 24 ++++++++++++------------ sli/tokenstack.h | 16 ++++++++-------- sli/triedatum.h | 6 +++--- sli/typechk.h | 4 ++-- 36 files changed, 124 insertions(+), 118 deletions(-) diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index b6f0cc3de7..2891217342 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -121,25 +121,25 @@ class lockPTR } D* - get( ) const + get() const { return pointee; } bool - islocked( ) const + islocked() const { return locked; } bool - isdeletable( ) const + isdeletable() const { return deletable; } void - lock( ) + lock() { assert( not locked ); #pragma omp atomic write // To avoid race conditions. @@ -147,7 +147,7 @@ class lockPTR } void - unlock( ) + unlock() { assert( locked ); #pragma omp atomic write // To avoid race conditions. @@ -215,7 +215,7 @@ class lockPTR } D* - get( ) + get() { assert( not obj->islocked() ); obj->lock(); // Try to lock Object @@ -223,7 +223,7 @@ class lockPTR } D* - get( ) const + get() const { assert( not obj->islocked() ); @@ -296,49 +296,49 @@ class lockPTR bool - valid( ) const //!< returns true if and only if obj->pointee != NULL + valid() const //!< returns true if and only if obj->pointee != NULL { assert( obj != NULL ); return ( obj->get() != NULL ); } bool - islocked( ) const + islocked() const { assert( obj != NULL ); return ( obj->islocked() ); } bool - deletable( ) const + deletable() const { assert( obj != NULL ); return ( obj->isdeletable() ); } void - lock( ) const + lock() const { assert( obj != NULL ); obj->lock(); } void - unlock( ) const + unlock() const { assert( obj != NULL ); obj->unlock(); } void - unlock( ) + unlock() { assert( obj != NULL ); obj->unlock(); } size_t - references( ) const + references() const { return ( obj == NULL ) ? 0 : obj.use_count(); } diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 044465f9d2..86237bd01e 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -181,7 +181,7 @@ ModelsModule::~ModelsModule() } const std::string -ModelsModule::name( ) const +ModelsModule::name() const { return std::string( "NEST Standard Models Module" ); // Return name of the module } diff --git a/nestkernel/connector_base.h b/nestkernel/connector_base.h index a76aa85d2c..7e986bf922 100644 --- a/nestkernel/connector_base.h +++ b/nestkernel/connector_base.h @@ -412,7 +412,8 @@ class Connector : public ConnectorBase } // Implemented in connector_base_impl.h - void send_weight_event( const thread tid, const unsigned int lcid, Event& e, const CommonSynapseProperties& cp ) override; + void + send_weight_event( const thread tid, const unsigned int lcid, Event& e, const CommonSynapseProperties& cp ) override; void trigger_update_weight( const long vt_node_id, @@ -469,7 +470,9 @@ class Connector : public ConnectorBase } index - find_matching_target( const thread tid, const std::vector< index >& matching_lcids, const index target_node_id ) const override + find_matching_target( const thread tid, + const std::vector< index >& matching_lcids, + const index target_node_id ) const override { for ( size_t i = 0; i < matching_lcids.size(); ++i ) { diff --git a/nestkernel/dynamicloader.cpp b/nestkernel/dynamicloader.cpp index 2bae8c6186..7842faec2c 100644 --- a/nestkernel/dynamicloader.cpp +++ b/nestkernel/dynamicloader.cpp @@ -116,13 +116,13 @@ DynamicLoaderModule::~DynamicLoaderModule() // The following concerns the new module: ----------------------- const std::string -DynamicLoaderModule::name( ) const +DynamicLoaderModule::name() const { return std::string( "NEST-Dynamic Loader" ); // Return name of the module } const std::string -DynamicLoaderModule::commandstring( ) const +DynamicLoaderModule::commandstring() const { return std::string( "" ); // Run associated SLI startup script } diff --git a/nestkernel/dynamicloader.h b/nestkernel/dynamicloader.h index a4613aae18..532f590350 100644 --- a/nestkernel/dynamicloader.h +++ b/nestkernel/dynamicloader.h @@ -62,8 +62,8 @@ class DynamicLoaderModule : public SLIModule void init( SLIInterpreter* ) override; - const std::string commandstring( ) const override; - const std::string name( ) const override; + const std::string commandstring() const override; + const std::string name() const override; /** diff --git a/nestkernel/growth_curve.h b/nestkernel/growth_curve.h index cdd90daa1f..033b6b37eb 100644 --- a/nestkernel/growth_curve.h +++ b/nestkernel/growth_curve.h @@ -133,7 +133,8 @@ class GrowthCurveLinear : public GrowthCurve GrowthCurveLinear(); void get( DictionaryDatum& d ) const override; void set( const DictionaryDatum& d ) override; - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; + double + update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eps_; @@ -220,7 +221,8 @@ class GrowthCurveGaussian : public GrowthCurve GrowthCurveGaussian(); void get( DictionaryDatum& d ) const override; void set( const DictionaryDatum& d ) override; - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; + double + update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eta_; @@ -292,7 +294,8 @@ class GrowthCurveSigmoid : public GrowthCurve GrowthCurveSigmoid(); void get( DictionaryDatum& d ) const override; void set( const DictionaryDatum& d ) override; - double update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; + double + update( double t, double t_minus, double Ca_minus, double z, double tau_Ca, double growth_rate ) const override; private: double eps_; diff --git a/nestkernel/model.cpp b/nestkernel/model.cpp index 602452ffa5..0e52e2b3b4 100644 --- a/nestkernel/model.cpp +++ b/nestkernel/model.cpp @@ -118,7 +118,7 @@ Model::set_status( DictionaryDatum d ) } DictionaryDatum -Model::get_status( ) +Model::get_status() { DictionaryDatum d = get_status_(); diff --git a/nestkernel/model.h b/nestkernel/model.h index 6f780dc90b..4a074b7209 100644 --- a/nestkernel/model.h +++ b/nestkernel/model.h @@ -143,7 +143,7 @@ class Model * @param d Dictionary. * @ingroup status_interface */ - DictionaryDatum get_status( ); + DictionaryDatum get_status(); virtual port send_test_event( Node&, rport, synindex, bool ) = 0; @@ -168,7 +168,7 @@ class Model /** * Return const reference to the prototype. */ - virtual Node const& get_prototype( ) const = 0; + virtual Node const& get_prototype() const = 0; /** * Set the model id on the prototype. diff --git a/nestkernel/music_manager.cpp b/nestkernel/music_manager.cpp index 416f1c4018..6e6659f50d 100644 --- a/nestkernel/music_manager.cpp +++ b/nestkernel/music_manager.cpp @@ -30,11 +30,11 @@ #endif // C++ includes: -//#include +// #include // Includes from libnestutil: #include "compose.hpp" -//#include "logging.h" +// #include "logging.h" // Includes from nestkernel: #include "kernel_manager.h" diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index 23ec0f87aa..78aa65c9a6 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -95,13 +95,13 @@ NestModule::~NestModule() // The following concerns the new module: const std::string -NestModule::name( ) const +NestModule::name() const { return std::string( "NEST Kernel 2" ); // Return name of the module } const std::string -NestModule::commandstring( ) const +NestModule::commandstring() const { return std::string( "(nest-init) run" ); } @@ -156,7 +156,7 @@ NestModule::create_parameter( const Name& name, const DictionaryDatum& d ) } GenericFactory< Parameter >& -NestModule::parameter_factory_( ) +NestModule::parameter_factory_() { static GenericFactory< Parameter > factory; return factory; @@ -164,7 +164,7 @@ NestModule::parameter_factory_( ) GenericFactory< AbstractMask >& -NestModule::mask_factory_( ) +NestModule::mask_factory_() { static GenericFactory< AbstractMask > factory; return factory; diff --git a/nestkernel/nestmodule.h b/nestkernel/nestmodule.h index 88d91f9058..4f5fe1b467 100644 --- a/nestkernel/nestmodule.h +++ b/nestkernel/nestmodule.h @@ -72,8 +72,8 @@ class NestModule : public SLIModule void init( SLIInterpreter* ) override; - const std::string commandstring( ) const override; - const std::string name( ) const override; + const std::string commandstring() const override; + const std::string name() const override; static sharedPtrDatum< Parameter, &ParameterType > create_parameter( const Token& ); static Parameter* create_parameter( const Name& name, const DictionaryDatum& d ); diff --git a/nestkernel/position.h b/nestkernel/position.h index 2a96dd0ab1..6be6fc9535 100644 --- a/nestkernel/position.h +++ b/nestkernel/position.h @@ -300,7 +300,7 @@ class Position /** * Output the Position to an ostream. */ - friend std::ostream& operator<<<>( std::ostream& os, const Position< D, T >& pos ); + friend std::ostream& operator<< <>( std::ostream& os, const Position< D, T >& pos ); protected: std::array< T, D > x_; diff --git a/sli/allocator.cpp b/sli/allocator.cpp index 554bb9411e..f74d1b742c 100644 --- a/sli/allocator.cpp +++ b/sli/allocator.cpp @@ -134,7 +134,7 @@ sli::pool::grow( size_t nelements ) } void -sli::pool::grow( ) +sli::pool::grow() { grow( block_size ); block_size *= growth_factor; diff --git a/sli/allocator.h b/sli/allocator.h index 041322b027..cd0db9d7c7 100644 --- a/sli/allocator.h +++ b/sli/allocator.h @@ -84,7 +84,7 @@ class pool } size_t - size( ) const + size() const { return csize; } @@ -133,15 +133,15 @@ class pool void reserve_additional( size_t n ); size_t - available( ) const + available() const { return total - instantiations; } - inline void* alloc( ); //!< allocate one element + inline void* alloc(); //!< allocate one element inline void free( void* p ); //!< put element back into the pool size_t - size_of( ) const + size_of() const { return el_size; } @@ -152,7 +152,7 @@ class pool }; inline void* -pool::alloc( ) +pool::alloc() { if ( head == nullptr ) diff --git a/sli/datum.h b/sli/datum.h index 197aa5d8d3..b13bfe0741 100644 --- a/sli/datum.h +++ b/sli/datum.h @@ -40,7 +40,7 @@ class Datum * Virtual copy constructor. * Use this function to lazily copy a datum. */ - virtual Datum* clone( ) const = 0; + virtual Datum* clone() const = 0; /** @@ -169,7 +169,7 @@ class Datum virtual void info( std::ostream& ) const; const Name& - gettypename( ) const + gettypename() const { return type->gettypename(); } @@ -192,7 +192,7 @@ template < SLIType* slt > class TypedDatum : public Datum { public: - TypedDatum( ) + TypedDatum() : Datum( slt ) { } diff --git a/sli/dict.h b/sli/dict.h index f7c6507b98..db7fdf11af 100644 --- a/sli/dict.h +++ b/sli/dict.h @@ -132,7 +132,7 @@ class Dictionary : private TokenMap Token& operator[]( const char* ); bool - empty( ) const + empty() const { return TokenMap::empty(); } diff --git a/sli/dictstack.h b/sli/dictstack.h index 7fb75c7282..25b3170a15 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -66,7 +66,7 @@ #define DICTSTACK_CACHE 1 #endif -//#undef DICTSTACK_CACHE +// #undef DICTSTACK_CACHE class DictionaryStack { diff --git a/sli/filesystem.h b/sli/filesystem.h index 08a8dc8c3a..e7768b74e1 100644 --- a/sli/filesystem.h +++ b/sli/filesystem.h @@ -113,12 +113,12 @@ class FilesystemModule : public SLIModule TmpNamFunction tmpnamfunction; CompareFilesFunction comparefilesfunction; - FilesystemModule( ) {}; + FilesystemModule() {}; ~FilesystemModule() override {}; void init( SLIInterpreter* ) override; - const std::string name( ) const override; - const std::string commandstring( ) const override; + const std::string name() const override; + const std::string commandstring() const override; }; #endif diff --git a/sli/genericdatum.h b/sli/genericdatum.h index 43620e97e2..ea8be03c7e 100644 --- a/sli/genericdatum.h +++ b/sli/genericdatum.h @@ -38,7 +38,7 @@ class GenericDatum : public TypedDatum< slt > { virtual Datum* - clone( ) const + clone() const { return new GenericDatum< D, slt >( *this ); } @@ -71,13 +71,13 @@ class GenericDatum : public TypedDatum< slt > } const D& - get( ) const + get() const { return d; } D& - get( ) + get() { return d; } diff --git a/sli/interpret.h b/sli/interpret.h index 059b852617..07a134b10c 100644 --- a/sli/interpret.h +++ b/sli/interpret.h @@ -86,10 +86,10 @@ class SLIInterpreter int verbositylevel; - void inittypes( ); - void initdictionaries( ); - void initbuiltins( ); - void initexternals( ); + void inittypes(); + void initdictionaries(); + void initbuiltins(); + void initexternals(); public: unsigned long code_accessed; // for code coverage analysis. @@ -251,7 +251,7 @@ class SLIInterpreter TokenStack EStack; // public member functions: - SLIInterpreter( ); + SLIInterpreter(); ~SLIInterpreter(); //! Initialise the interpreter by reading in the startup files. @@ -340,7 +340,7 @@ class SLIInterpreter void basedef_move( const Name& n, Token& t ); void setcycleguard( Index ); - void removecycleguard( ); + void removecycleguard(); /** @@ -752,7 +752,7 @@ class SLIInterpreter * @see raiseerror(const char*), raiseerror(Name), * raiseerror(Name,Name) */ - void raiseagain( ); + void raiseagain(); /** TO BE DOCUMENTED. * @todo Document this function. @@ -798,7 +798,7 @@ class SLIInterpreter * error(), fatal() * @ingroup SLIMessaging */ - int verbosity( ) const; + int verbosity() const; /** Display a message. * @param level The error level that shall be associated with the @@ -845,17 +845,17 @@ class SLIInterpreter void terminate( int returnvalue = -1 ); //******************************************************* - Name getcurrentname( ) const; + Name getcurrentname() const; unsigned long - cycles( ) const + cycles() const { return cycle_count; } template < class T > - void addmodule( ); + void addmodule(); void addmodule( SLIModule* ); /* @@ -866,8 +866,8 @@ class SLIInterpreter */ void addlinkedusermodule( SLIModule* ); - FunctionDatum* Ilookup( ) const; - FunctionDatum* Iiterate( ) const; + FunctionDatum* Ilookup() const; + FunctionDatum* Iiterate() const; /** * Throw StackUnderflow exception if too few elements on stack. @@ -893,7 +893,7 @@ addmodule( SLIInterpreter& i ) template < class T > void -SLIInterpreter::addmodule( ) +SLIInterpreter::addmodule() { SLIModule* m = new T(); diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index 167da29948..282efd8fbe 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -43,7 +43,7 @@ template < class D, SLIType* slt > class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > { Datum* - clone( ) const + clone() const { return new lockPTRDatum< D, slt >( *this ); } diff --git a/sli/namedatum.h b/sli/namedatum.h index b404d04d30..e3bc937417 100644 --- a/sli/namedatum.h +++ b/sli/namedatum.h @@ -67,7 +67,7 @@ sli::pool AggregateDatum< Name, &SLIInterpreter::Literaltype >::memory; class NameDatum : public AggregateDatum< Name, &SLIInterpreter::Nametype > { Datum* - clone( ) const override + clone() const override { return new NameDatum( *this ); } @@ -98,7 +98,7 @@ class NameDatum : public AggregateDatum< Name, &SLIInterpreter::Nametype > class LiteralDatum : public AggregateDatum< Name, &SLIInterpreter::Literaltype > { Datum* - clone( ) const override + clone() const override { return new LiteralDatum( *this ); } diff --git a/sli/numericdatum.h b/sli/numericdatum.h index 4950cb8760..5f3aad573c 100644 --- a/sli/numericdatum.h +++ b/sli/numericdatum.h @@ -47,7 +47,7 @@ class NumericDatum : public GenericDatum< D, slt > private: Datum* - clone( ) const + clone() const { return new NumericDatum< D, slt >( *this ); } diff --git a/sli/parser.h b/sli/parser.h index 5ffb0d4e43..b623ee2856 100644 --- a/sli/parser.h +++ b/sli/parser.h @@ -59,7 +59,7 @@ class Parser void init( std::istream& ); public: - Parser( ); + Parser(); Parser( std::istream& ); bool operator()( Token& ); @@ -78,7 +78,7 @@ class Parser } Scanner const* - scan( ) const + scan() const { return s; } diff --git a/sli/parserdatum.h b/sli/parserdatum.h index 716dabf6a3..169f65c7c5 100644 --- a/sli/parserdatum.h +++ b/sli/parserdatum.h @@ -31,12 +31,12 @@ class ParserDatum : public AggregateDatum< Parser, &SLIInterpreter::Parsertype > { Datum* - clone( ) const + clone() const { return new ParserDatum( *this ); } - ParserDatum( ) + ParserDatum() { set_executable(); } diff --git a/sli/processes.h b/sli/processes.h index e8fe99c1d7..601a28538e 100644 --- a/sli/processes.h +++ b/sli/processes.h @@ -140,7 +140,7 @@ class Processes : public SLIModule const Name EXDEV_name; // The constructor and destructor for our module object (-if we need them-): - Processes( ) + Processes() : signaldict_name( "signaldict" ) , SIGABRT_name( "SIGABRT" ) , SIGALRM_name( "SIGALRM" ) @@ -207,17 +207,17 @@ class Processes : public SLIModule { } // Processes constructor - ~Processes( ) override; // clean up dynmem for static variables... + ~Processes() override; // clean up dynmem for static variables... // The Module is registered by a call to this Function: void init( SLIInterpreter* ) override; // This function will return the name of our module: - const std::string name( ) const override; + const std::string name() const override; // This function -may- return a string of SLI-commands to be executed for // initialization - const std::string commandstring( ) const override; + const std::string commandstring() const override; // --------------------------------------------------------------- diff --git a/sli/scanner.h b/sli/scanner.h index 77114c298b..62d2f29fe8 100644 --- a/sli/scanner.h +++ b/sli/scanner.h @@ -163,7 +163,7 @@ class Scanner * Return input stream. */ std::istream* - GetSource( ) + GetSource() { return in; } diff --git a/sli/sharedptrdatum.h b/sli/sharedptrdatum.h index 8e09aaf0ac..4b9fa0f8f1 100644 --- a/sli/sharedptrdatum.h +++ b/sli/sharedptrdatum.h @@ -35,7 +35,7 @@ template < class D, SLIType* slt > class sharedPtrDatum : public std::shared_ptr< D >, public TypedDatum< slt > { Datum* - clone( ) const + clone() const { return new sharedPtrDatum< D, slt >( *this ); } diff --git a/sli/sliarray.h b/sli/sliarray.h index 8cdd8f0d8e..1ed3525a8b 100644 --- a/sli/sliarray.h +++ b/sli/sliarray.h @@ -637,8 +637,8 @@ class SLIArrayModule : public SLIModule } void init( SLIInterpreter* ) override; - const std::string commandstring( ) const override; - const std::string name( ) const override; + const std::string commandstring() const override; + const std::string name() const override; }; diff --git a/sli/specialfunctionsmodule.h b/sli/specialfunctionsmodule.h index 361f1e18d4..679d2cfbd5 100644 --- a/sli/specialfunctionsmodule.h +++ b/sli/specialfunctionsmodule.h @@ -53,14 +53,14 @@ class SpecialFunctionsModule : public SLIModule // Part 1: Methods pertaining to the module ---------------------- public: - SpecialFunctionsModule( ) {}; + SpecialFunctionsModule() {}; // ~SpecialFunctionsModule(void); // The Module is registered by a call to this Function: void init( SLIInterpreter* ) override; // This function will return the name of our module: - const std::string name( ) const override; + const std::string name() const override; // Part 2: Classes for the implemented functions ----------------- @@ -121,8 +121,8 @@ class SpecialFunctionsModule : public SLIModule void execute( SLIInterpreter* ) const override; // need constructor and destructor to set up integration workspace - GaussDiskConvFunction( ); - ~GaussDiskConvFunction( ) override; + GaussDiskConvFunction(); + ~GaussDiskConvFunction() override; private: // quadrature parameters, see GSL Reference diff --git a/sli/symboldatum.h b/sli/symboldatum.h index 14b1d870ed..8b3a5b6c95 100644 --- a/sli/symboldatum.h +++ b/sli/symboldatum.h @@ -51,7 +51,7 @@ sli::pool AggregateDatum< Name, &SLIInterpreter::Symboltype >::memory; class SymbolDatum : public AggregateDatum< Name, &SLIInterpreter::Symboltype > { Datum* - clone( ) const override + clone() const override { return new SymbolDatum( *this ); } diff --git a/sli/token.h b/sli/token.h index 229458c861..a400970927 100644 --- a/sli/token.h +++ b/sli/token.h @@ -334,7 +334,7 @@ class Token } void - clear( ) + clear() { if ( p ) { @@ -350,19 +350,19 @@ class Token } bool - empty( ) const + empty() const { return p == nullptr; } bool - operator not( ) const + operator not() const { return p == nullptr; } Datum* - datum( ) const + datum() const { accessed_ = true; return p; @@ -392,7 +392,7 @@ class Token const std::type_info& - type( ) const + type() const { return typeid( *p ); } diff --git a/sli/tokenarray.h b/sli/tokenarray.h index 78a9ade76d..05583b4261 100644 --- a/sli/tokenarray.h +++ b/sli/tokenarray.h @@ -68,7 +68,7 @@ class TokenArray TokenArrayObj* data; bool - clone( ) + clone() { if ( data->references() > 1 ) { @@ -83,7 +83,7 @@ class TokenArray } bool - detach( ) + detach() { if ( data->references() > 1 ) { @@ -106,7 +106,7 @@ class TokenArray } public: - TokenArray( ) + TokenArray() : data( new TokenArrayObj() ) {}; explicit TokenArray( size_t n, const Token& t = Token(), size_t alloc = 128 ) @@ -156,7 +156,7 @@ class TokenArray * Return number of elements in the array. */ size_t - size( ) const + size() const { return data->size(); } @@ -165,7 +165,7 @@ class TokenArray * Return maximal number of elements that fit into the container. */ size_t - capacity( ) const + capacity() const { return data->capacity(); } @@ -227,7 +227,7 @@ class TokenArray * invalidated. */ bool - shrink( ) + shrink() { return data->shrink(); } @@ -244,7 +244,7 @@ class TokenArray } unsigned int - references( ) + references() { return data->references(); } @@ -360,20 +360,20 @@ class TokenArray } void - pop_back( ) + pop_back() { clone(); data->pop_back(); } void - clear( ) + clear() { erase(); } void - erase( ) + erase() { if ( not detach() ) { @@ -435,7 +435,7 @@ class TokenArray } bool - empty( ) const + empty() const { return size() == 0; } @@ -449,7 +449,7 @@ class TokenArray void toVector( std::vector< double >& ) const; void toVector( std::vector< std::string >& ) const; - bool valid( ) const; // check integrity + bool valid() const; // check integrity /** Exception classes */ // class TypeMismatch {}; diff --git a/sli/tokenstack.h b/sli/tokenstack.h index da86615cbf..7ffb99ba35 100644 --- a/sli/tokenstack.h +++ b/sli/tokenstack.h @@ -52,7 +52,7 @@ class TokenStack : private TokenArrayObj using TokenArrayObj::reserve_token; void - clear( ) + clear() { erase( begin(), end() ); } @@ -93,7 +93,7 @@ class TokenStack : private TokenArrayObj } void - pop( ) + pop() { pop_back(); } @@ -113,12 +113,12 @@ class TokenStack : private TokenArrayObj Token& - top( ) + top() { return *( end() - 1 ); } const Token& - top( ) const + top() const { return *( end() - 1 ); } @@ -140,7 +140,7 @@ class TokenStack : private TokenArrayObj void - swap( ) + swap() { ( end() - 1 )->swap( *( end() - 2 ) ); } @@ -176,12 +176,12 @@ class TokenStack : private TokenArrayObj } Index - size( ) const + size() const { return TokenArrayObj::capacity(); } Index - load( ) const + load() const { return TokenArrayObj::size(); } @@ -189,7 +189,7 @@ class TokenStack : private TokenArrayObj void dump( std::ostream& ) const; TokenArray - toArray( ) const + toArray() const { return TokenArray( *this ); } diff --git a/sli/triedatum.h b/sli/triedatum.h index 2cc72e89a5..cf765f3765 100644 --- a/sli/triedatum.h +++ b/sli/triedatum.h @@ -45,7 +45,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > TypeTrie tree; Datum* - clone( ) const override + clone() const override { return new TrieDatum( *this ); } @@ -104,7 +104,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > bool equals( Datum const* ) const override; const Name& - getname( ) const + getname() const { return name; } @@ -128,7 +128,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > } TypeTrie& - get( ) + get() { return tree; } diff --git a/sli/typechk.h b/sli/typechk.h index 38e557a814..4f51fef722 100644 --- a/sli/typechk.h +++ b/sli/typechk.h @@ -87,13 +87,13 @@ class TypeTrie void - addreference( ) + addreference() { ++refs; } void - removereference( ) + removereference() { if ( --refs == 0 ) { From d4a830c675b3eb9ddf88e037cdf481b8f92e42fe Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 11:52:24 +0200 Subject: [PATCH 053/150] Added explicit specifiers to single-parameter constructors --- libnestutil/lockptr.h | 4 ++-- nestkernel/dynamicloader.h | 4 ++-- nestkernel/exceptions.h | 10 +++++----- nestkernel/nest_time.h | 10 +++++----- nestkernel/ntree.h | 2 +- nestkernel/parameter.h | 4 ++-- nestkernel/position.h | 6 +++--- nestkernel/random_generators.h | 2 +- sli/datum.h | 4 ++-- sli/genericdatum.h | 2 +- sli/name.h | 4 ++-- sli/numericdatum.h | 2 +- sli/token.h | 2 +- 13 files changed, 28 insertions(+), 28 deletions(-) diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index 2891217342..19b5ebc1e5 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -97,14 +97,14 @@ class lockPTR PointerObject( PointerObject const& ); public: - PointerObject( D* p = NULL ) + explicit PointerObject( D* p = NULL ) : pointee( p ) , deletable( true ) , locked( false ) { } - PointerObject( D& p_o ) + explicit PointerObject( D& p_o ) : pointee( &p_o ) , deletable( false ) , locked( false ) diff --git a/nestkernel/dynamicloader.h b/nestkernel/dynamicloader.h index 532f590350..406669c77f 100644 --- a/nestkernel/dynamicloader.h +++ b/nestkernel/dynamicloader.h @@ -57,7 +57,7 @@ typedef std::vector< SLIModule* > vecLinkedModules; class DynamicLoaderModule : public SLIModule { public: - DynamicLoaderModule( SLIInterpreter& interpreter ); + explicit DynamicLoaderModule( SLIInterpreter& interpreter ); ~DynamicLoaderModule() override; void init( SLIInterpreter* ) override; @@ -82,7 +82,7 @@ class DynamicLoaderModule : public SLIModule class LoadModuleFunction : public SLIFunction { public: - LoadModuleFunction( vecDynModules& dyn_modules ); + explicit LoadModuleFunction( vecDynModules& dyn_modules ); private: void execute( SLIInterpreter* ) const override; diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index 7ac62d5155..edc2997aab 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -63,12 +63,12 @@ class KernelException : public SLIException { } - KernelException( char const* const what ) + explicit KernelException( char const* const what ) : SLIException( what ) { } - KernelException( const std::string& what ) + explicit KernelException( const std::string& what ) : SLIException( what ) { } @@ -95,7 +95,7 @@ class UnknownModelName : public KernelException const Name n_; public: - UnknownModelName( const Name& n ) + explicit UnknownModelName( const Name& n ) : KernelException( "UnknownModelName" ) , n_( n ) { @@ -118,7 +118,7 @@ class UnknownComponent : public KernelException const Name n_; public: - UnknownComponent( const Name& n ) + explicit UnknownComponent( const Name& n ) : KernelException( "UnknownComponent" ) , n_( n ) { @@ -140,7 +140,7 @@ class NewModelNameExists : public KernelException const Name n_; public: - NewModelNameExists( const Name& n ) + explicit NewModelNameExists( const Name& n ) : KernelException( "NewModelNameExists" ) , n_( n ) { diff --git a/nestkernel/nest_time.h b/nestkernel/nest_time.h index cb3f115e0f..6e12933e1d 100644 --- a/nestkernel/nest_time.h +++ b/nestkernel/nest_time.h @@ -216,7 +216,7 @@ class Time , ms( ms ) { } - Limit( const tic_t& ); + explicit Limit( const tic_t& ); }; static Limit LIM_MAX; static Limit LIM_MIN; @@ -301,21 +301,21 @@ class Time // Defined by compiler. // Time(const Time& t); - Time( tic t ) + explicit Time( tic t ) : tics( ( time_abs( t.t ) < LIM_MAX.tics ) ? t.t : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) { } - Time( step t ) + explicit Time( step t ) : tics( ( time_abs( t.t ) < LIM_MAX.steps ) ? t.t * Range::TICS_PER_STEP : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) { } - Time( ms t ) + explicit Time( ms t ) : tics( ( time_abs( t.t ) < LIM_MAX.ms ) ? static_cast< tic_t >( t.t * Range::TICS_PER_MS + 0.5 ) : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) @@ -323,7 +323,7 @@ class Time } static tic_t fromstamp( ms_stamp ); - Time( ms_stamp t ) + explicit Time( ms_stamp t ) : tics( fromstamp( t ) ) { } diff --git a/nestkernel/ntree.h b/nestkernel/ntree.h index 5594666652..6713c2417a 100644 --- a/nestkernel/ntree.h +++ b/nestkernel/ntree.h @@ -81,7 +81,7 @@ class Ntree * Initialize an iterator to point to the first node in the first * non-empty leaf within the tree below this Ntree. */ - iterator( Ntree& q ); + explicit iterator( Ntree& q ); /** * Initialize an iterator to point to the nth node in this Ntree, diff --git a/nestkernel/parameter.h b/nestkernel/parameter.h index 84b2f4fd98..c08d793d2c 100644 --- a/nestkernel/parameter.h +++ b/nestkernel/parameter.h @@ -62,7 +62,7 @@ class Parameter /** * Copy constructor */ - Parameter( const Parameter& p ) = default; + explicit Parameter( const Parameter& p ) = default; /** * Virtual destructor @@ -133,7 +133,7 @@ class ConstantParameter : public Parameter * Creates a ConstantParameter with a specified value. * @param value parameter value */ - ConstantParameter( double value ) + explicit ConstantParameter( double value ) : value_( value ) { } diff --git a/nestkernel/position.h b/nestkernel/position.h index 6be6fc9535..6f8875f619 100644 --- a/nestkernel/position.h +++ b/nestkernel/position.h @@ -80,12 +80,12 @@ class Position /** * Constructor initializing a Position from an array. */ - Position( const T* const y ); + explicit Position( const T* const y ); /** * Constructor initializing a Position from a std::vector. */ - Position( const std::vector< T >& y ); + explicit Position( const std::vector< T >& y ); /** * Copy constructor. @@ -340,7 +340,7 @@ class MultiIndex : public Position< D, int > { } - MultiIndex( const Position< D, int >& ur ) + explicit MultiIndex( const Position< D, int >& ur ) : Position< D, int >() , lower_left_() , upper_right_( ur ) diff --git a/nestkernel/random_generators.h b/nestkernel/random_generators.h index 30acf53193..0bbc4fc8cd 100644 --- a/nestkernel/random_generators.h +++ b/nestkernel/random_generators.h @@ -127,7 +127,7 @@ class RandomGenerator final : public BaseRandomGenerator RandomGenerator() = delete; RandomGenerator( const RandomEngineT& rng ) = delete; - RandomGenerator( std::initializer_list< std::uint32_t > seed ) + explicit RandomGenerator( std::initializer_list< std::uint32_t > seed ) : rng_() , uniform_double_dist_0_1_( 0.0, 1.0 ) { diff --git a/sli/datum.h b/sli/datum.h index b13bfe0741..a335c566bf 100644 --- a/sli/datum.h +++ b/sli/datum.h @@ -75,7 +75,7 @@ class Datum } - Datum( const SLIType* t ) + explicit Datum( const SLIType* t ) : type( t ) , action( t->getaction() ) , reference_count_( 1 ) @@ -83,7 +83,7 @@ class Datum { } - Datum( const Datum& d ) + explicit Datum( const Datum& d ) : type( d.type ) , action( d.action ) , reference_count_( 1 ) diff --git a/sli/genericdatum.h b/sli/genericdatum.h index ea8be03c7e..97bde9badc 100644 --- a/sli/genericdatum.h +++ b/sli/genericdatum.h @@ -55,7 +55,7 @@ class GenericDatum : public TypedDatum< slt > { } - GenericDatum( const D& d_s ) + explicit GenericDatum( const D& d_s ) : d( d_s ) { TypedDatum< slt >::unset_executable(); diff --git a/sli/name.h b/sli/name.h index a77bba761a..b470fdabe9 100644 --- a/sli/name.h +++ b/sli/name.h @@ -64,11 +64,11 @@ class Name { } - Name( const char s[] ) + explicit Name( const char s[] ) : handle_( insert( std::string( s ) ) ) { } - Name( const std::string& s ) + explicit Name( const std::string& s ) : handle_( insert( s ) ) { } diff --git a/sli/numericdatum.h b/sli/numericdatum.h index 5f3aad573c..8b9d450306 100644 --- a/sli/numericdatum.h +++ b/sli/numericdatum.h @@ -57,7 +57,7 @@ class NumericDatum : public GenericDatum< D, slt > { d = ( D ) 0; } - NumericDatum( const D& d_s ) + explicit NumericDatum( const D& d_s ) { d = d_s; } diff --git a/sli/token.h b/sli/token.h index a400970927..35f343d826 100644 --- a/sli/token.h +++ b/sli/token.h @@ -184,7 +184,7 @@ class Token /** * use existing pointer to datum, token takes responsibility of the pointer. */ - Token( Datum* p_s = nullptr ) + explicit Token( Datum* p_s = nullptr ) : p( p_s ) { } From 48e61e45a3d6e5933dcb0f41b36758475daa2e4d Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 12:00:27 +0200 Subject: [PATCH 054/150] Reverted clang formatting for file position.h, as static_checks complain (probably because of a different clang format version) --- nestkernel/position.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/position.h b/nestkernel/position.h index 6f8875f619..d4a48ddbb8 100644 --- a/nestkernel/position.h +++ b/nestkernel/position.h @@ -300,7 +300,7 @@ class Position /** * Output the Position to an ostream. */ - friend std::ostream& operator<< <>( std::ostream& os, const Position< D, T >& pos ); + friend std::ostream& operator<<<>( std::ostream& os, const Position< D, T >& pos ); protected: std::array< T, D > x_; From 2575ef6f05317e88bb1e8fd02a807a5596154e72 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 14:08:05 +0200 Subject: [PATCH 055/150] Marking some single parameter constructors implicit where it makes life more convenient --- nestkernel/nest_time.h | 22 +++++++++++----------- nestkernel/position.h | 6 +++--- sli/name.h | 4 ++-- sli/numericdatum.h | 2 +- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/nestkernel/nest_time.h b/nestkernel/nest_time.h index 6e12933e1d..42aa40a433 100644 --- a/nestkernel/nest_time.h +++ b/nestkernel/nest_time.h @@ -216,7 +216,7 @@ class Time , ms( ms ) { } - explicit Limit( const tic_t& ); + Limit( const tic_t& ); }; static Limit LIM_MAX; static Limit LIM_MIN; @@ -246,14 +246,14 @@ class Time struct tic { tic_t t; - explicit tic( tic_t t ) + tic( tic_t t ) : t( t ) {}; }; struct step { delay t; - explicit step( delay t ) + step( delay t ) : t( t ) { } @@ -262,20 +262,20 @@ class Time struct ms { double t; - explicit ms( double t ) + ms( double t ) : t( t ) { } static double fromtoken( const Token& t ); - explicit ms( const Token& t ) + ms( const Token& t ) : t( fromtoken( t ) ) {}; }; struct ms_stamp { double t; - explicit ms_stamp( double t ) + ms_stamp( double t ) : t( t ) { } @@ -286,7 +286,7 @@ class Time ///////////////////////////////////////////////////////////// protected: - explicit Time( tic_t tics ) + Time( tic_t tics ) : tics( tics ) { } // This doesn't check ranges. @@ -301,21 +301,21 @@ class Time // Defined by compiler. // Time(const Time& t); - explicit Time( tic t ) + Time( tic t ) : tics( ( time_abs( t.t ) < LIM_MAX.tics ) ? t.t : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) { } - explicit Time( step t ) + Time( step t ) : tics( ( time_abs( t.t ) < LIM_MAX.steps ) ? t.t * Range::TICS_PER_STEP : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) { } - explicit Time( ms t ) + Time( ms t ) : tics( ( time_abs( t.t ) < LIM_MAX.ms ) ? static_cast< tic_t >( t.t * Range::TICS_PER_MS + 0.5 ) : ( t.t < 0 ) ? LIM_NEG_INF.tics : LIM_POS_INF.tics ) @@ -323,7 +323,7 @@ class Time } static tic_t fromstamp( ms_stamp ); - explicit Time( ms_stamp t ) + Time( ms_stamp t ) : tics( fromstamp( t ) ) { } diff --git a/nestkernel/position.h b/nestkernel/position.h index d4a48ddbb8..a783b4244d 100644 --- a/nestkernel/position.h +++ b/nestkernel/position.h @@ -80,12 +80,12 @@ class Position /** * Constructor initializing a Position from an array. */ - explicit Position( const T* const y ); + Position( const T* const y ); /** * Constructor initializing a Position from a std::vector. */ - explicit Position( const std::vector< T >& y ); + Position( const std::vector< T >& y ); /** * Copy constructor. @@ -300,7 +300,7 @@ class Position /** * Output the Position to an ostream. */ - friend std::ostream& operator<<<>( std::ostream& os, const Position< D, T >& pos ); + friend std::ostream& operator<< <>( std::ostream& os, const Position< D, T >& pos ); protected: std::array< T, D > x_; diff --git a/sli/name.h b/sli/name.h index b470fdabe9..a77bba761a 100644 --- a/sli/name.h +++ b/sli/name.h @@ -64,11 +64,11 @@ class Name { } - explicit Name( const char s[] ) + Name( const char s[] ) : handle_( insert( std::string( s ) ) ) { } - explicit Name( const std::string& s ) + Name( const std::string& s ) : handle_( insert( s ) ) { } diff --git a/sli/numericdatum.h b/sli/numericdatum.h index 8b9d450306..5f3aad573c 100644 --- a/sli/numericdatum.h +++ b/sli/numericdatum.h @@ -57,7 +57,7 @@ class NumericDatum : public GenericDatum< D, slt > { d = ( D ) 0; } - explicit NumericDatum( const D& d_s ) + NumericDatum( const D& d_s ) { d = d_s; } From 8481c969850c700bce089db70d54b70fc76a9f58 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 14:15:20 +0200 Subject: [PATCH 056/150] Position.h clang format --- nestkernel/position.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/position.h b/nestkernel/position.h index a783b4244d..cc94582ad8 100644 --- a/nestkernel/position.h +++ b/nestkernel/position.h @@ -300,7 +300,7 @@ class Position /** * Output the Position to an ostream. */ - friend std::ostream& operator<< <>( std::ostream& os, const Position< D, T >& pos ); + friend std::ostream& operator<<<>( std::ostream& os, const Position< D, T >& pos ); protected: std::array< T, D > x_; From e86e6b4a23174427cc625d7647b87786e96a8f8e Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 30 Sep 2022 14:34:43 +0200 Subject: [PATCH 057/150] Improved clarity of `Dwith-python` error The legacy forms of `Dwith-python=2/3` still circulate. If a user now specifies `-Dwith-python=3` they are met with the message `Invalid option: -Dwith-python=3`. This message implies that the option `-Dwith-python` is invalid and unrecognized by CMake. I changed the error message to clarify that the given value is invalid, and `ON` or `OFF` should be given instead. --- cmake/ProcessOptions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/ProcessOptions.cmake b/cmake/ProcessOptions.cmake index 5098204140..101701ef83 100644 --- a/cmake/ProcessOptions.cmake +++ b/cmake/ProcessOptions.cmake @@ -415,7 +415,7 @@ function( NEST_PROCESS_WITH_PYTHON ) endif () elseif ( ${with-python} STREQUAL "OFF" ) else () - printError( "Invalid option: -Dwith-python=" ${with-python} ) + printError( "Invalid value -Dwith-python=${with-python}, please use 'ON' or 'OFF'" ) endif () endfunction() From bf1e22c0fb7bc1efaa2017b4220c0891fd35a28a Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 30 Sep 2022 15:35:40 +0200 Subject: [PATCH 058/150] Made some more constructors implicit --- sli/datum.h | 4 ++-- sli/genericdatum.h | 2 +- sli/token.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sli/datum.h b/sli/datum.h index a335c566bf..b13bfe0741 100644 --- a/sli/datum.h +++ b/sli/datum.h @@ -75,7 +75,7 @@ class Datum } - explicit Datum( const SLIType* t ) + Datum( const SLIType* t ) : type( t ) , action( t->getaction() ) , reference_count_( 1 ) @@ -83,7 +83,7 @@ class Datum { } - explicit Datum( const Datum& d ) + Datum( const Datum& d ) : type( d.type ) , action( d.action ) , reference_count_( 1 ) diff --git a/sli/genericdatum.h b/sli/genericdatum.h index 97bde9badc..ea8be03c7e 100644 --- a/sli/genericdatum.h +++ b/sli/genericdatum.h @@ -55,7 +55,7 @@ class GenericDatum : public TypedDatum< slt > { } - explicit GenericDatum( const D& d_s ) + GenericDatum( const D& d_s ) : d( d_s ) { TypedDatum< slt >::unset_executable(); diff --git a/sli/token.h b/sli/token.h index 35f343d826..a400970927 100644 --- a/sli/token.h +++ b/sli/token.h @@ -184,7 +184,7 @@ class Token /** * use existing pointer to datum, token takes responsibility of the pointer. */ - explicit Token( Datum* p_s = nullptr ) + Token( Datum* p_s = nullptr ) : p( p_s ) { } From 4c4fc6bc46811d0d7a77b0313bb19e1bb30db2b3 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:15:31 +0200 Subject: [PATCH 059/150] Update archiving_node.h --- nestkernel/archiving_node.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/archiving_node.h b/nestkernel/archiving_node.h index 6cc629364c..30e3f2d23d 100644 --- a/nestkernel/archiving_node.h +++ b/nestkernel/archiving_node.h @@ -103,7 +103,7 @@ class ArchivingNode : public StructuralPlasticityNode * \fn double get_K_triplet_value(std::deque::iterator &iter) * return the triplet Kminus value for the associated iterator. */ - // double get_K_triplet_value( const std::deque< histentry >::iterator& iter ); + double get_K_triplet_value( const std::deque< histentry >::iterator& iter ); /** * \fn void get_history(long t1, long t2, From af3bf3093e69bcb9441176e967f4786fd1ce5760 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:35:51 +0200 Subject: [PATCH 060/150] Added back explicit modifiers to nest_time --- nestkernel/nest_time.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/nestkernel/nest_time.h b/nestkernel/nest_time.h index 42aa40a433..6950abaf41 100644 --- a/nestkernel/nest_time.h +++ b/nestkernel/nest_time.h @@ -246,14 +246,14 @@ class Time struct tic { tic_t t; - tic( tic_t t ) + explicit tic( tic_t t ) : t( t ) {}; }; struct step { delay t; - step( delay t ) + explicit step( delay t ) : t( t ) { } @@ -262,20 +262,20 @@ class Time struct ms { double t; - ms( double t ) + explicit ms( double t ) : t( t ) { } static double fromtoken( const Token& t ); - ms( const Token& t ) + explicit ms( const Token& t ) : t( fromtoken( t ) ) {}; }; struct ms_stamp { double t; - ms_stamp( double t ) + explicit ms_stamp( double t ) : t( t ) { } From b53abec627165c3cde8bc8ca73b255d11d290b38 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:40:23 +0200 Subject: [PATCH 061/150] Remove unused functions and docstrings --- sli/dict.h | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/sli/dict.h b/sli/dict.h index db7fdf11af..e29d221b93 100644 --- a/sli/dict.h +++ b/sli/dict.h @@ -193,27 +193,6 @@ class Dictionary : private TokenMap */ typedef TokenMap::const_iterator const_iterator; - /** - * First element in dictionary. - * Dictionary inherits privately from std::map to hide implementation - * details. To allow for inspection of all elements in a dictionary, - * we export the constant iterator type and begin() and end() methods. - */ - // const_iterator begin() const; - - /** - * One-past-last element in dictionary. - * Dictionary inherits privately from std::map to hide implementation - * details. To allow for inspection of all elements in a dictionary, - * we export the constant iterator type and begin() and end() methods. - */ - // const_iterator end() const; - - /** - * - */ - // void initialize_property_array( Name propname ); - /** * This function is called when a dictionary is pushed to the dictionary * stack. The dictioray stack must keep track about which dictioraries are on From 31213c6bc6ac8ab4bd3101f559c7cf2ab6d90209 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:42:30 +0200 Subject: [PATCH 062/150] Remove unused macro --- sli/dictstack.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/sli/dictstack.h b/sli/dictstack.h index 25b3170a15..dea99ee357 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -66,8 +66,6 @@ #define DICTSTACK_CACHE 1 #endif -// #undef DICTSTACK_CACHE - class DictionaryStack { private: From 3e70e0bcba5b326c0f1c4a20412f362010b5b4a7 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:44:38 +0200 Subject: [PATCH 063/150] Remove unused function --- sli/{dictstack.h => sli/lockptrdatum.h} | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) rename sli/{dictstack.h => sli/lockptrdatum.h} (99%) diff --git a/sli/dictstack.h b/sli/sli/lockptrdatum.h similarity index 99% rename from sli/dictstack.h rename to sli/sli/lockptrdatum.h index dea99ee357..73baca4d0e 100644 --- a/sli/dictstack.h +++ b/sli/sli/lockptrdatum.h @@ -66,6 +66,8 @@ #define DICTSTACK_CACHE 1 #endif +// #undef DICTSTACK_CACHE + class DictionaryStack { private: @@ -333,9 +335,7 @@ class DictionaryStack * The Token is moved. */ void basedef_move( const Name& n, Token& t ); - - // bool where( const Name&, Token& ); - + void pop( void ); From 3288d8d22f416cdb51e579c294d9742b468edfe0 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:45:41 +0200 Subject: [PATCH 064/150] Uncomment operator== --- sli/lockptrdatum.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index 282efd8fbe..39ee4f8b82 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -114,7 +114,7 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > implementation is defined. */ private: - // bool operator==( lockPTR< D >& ); + bool operator==( lockPTR< D >& ); }; /* equals(const Datum* datum) From 4ef4572fba0d78d148c2f9c5d9ac15be90bda3ec Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:53:12 +0200 Subject: [PATCH 065/150] Add missing semicolon --- sli/tarrayobj.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index 6ce9e2c05f..a4c434045c 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -85,7 +85,7 @@ TokenArrayObj::allocate( size_t new_s, size_t new_c, size_t new_a, const Token& size_t old_s = size(); - assert( new_c != 0 ) + assert( new_c != 0 ); assert( new_a != 0 ); Token* h = new Token[ new_c ]; From f099a85b37b1aa57537fcff6628f82ae9a9dd5e3 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:54:49 +0200 Subject: [PATCH 066/150] Remove unused functions --- sli/token.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/sli/token.h b/sli/token.h index a400970927..a48ff48d93 100644 --- a/sli/token.h +++ b/sli/token.h @@ -208,16 +208,11 @@ class Token Token( const std::vector< double >& ); Token( const std::vector< long >& ); Token( const std::vector< size_t >& ); - // Token( const std::ostream& ); - // Token( const std::istream& ); - // operator Datum*() const; operator size_t() const; operator long() const; operator double() const; operator bool() const; operator std::string() const; - // operator vector const; - // operator vector const; /** * If the contained datum has more than one reference, clone it, so it can From 69c425b43870be1b6a408b0e18da1d78b56db382 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 10:57:23 +0200 Subject: [PATCH 067/150] Remove unused functions --- sli/tokenarray.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/sli/tokenarray.h b/sli/tokenarray.h index 05583b4261..0e4dc7a04c 100644 --- a/sli/tokenarray.h +++ b/sli/tokenarray.h @@ -425,8 +425,6 @@ class TokenArray } const TokenArray& operator=( const TokenArray& ); - // const TokenArray& operator=( const std::vector< long >& ); - // const TokenArray& operator=( const std::vector< double >& ); bool operator==( const TokenArray& a ) const @@ -440,8 +438,6 @@ class TokenArray return size() == 0; } - // void info( std::ostream& ) const; - /** Fill vectors with homogeneous integer and double arrays */ void toVector( std::vector< size_t >& ) const; @@ -452,7 +448,6 @@ class TokenArray bool valid() const; // check integrity /** Exception classes */ - // class TypeMismatch {}; class OutOfRange { }; From 0a41d4d2d173135e4de552967932e495f7b00a2d Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 11:10:46 +0200 Subject: [PATCH 068/150] Apply suggestions from code review Co-authored-by: Hans Ekkehard Plesser --- libnestutil/stopwatch.h | 2 +- models/glif_cond.cpp | 2 +- models/stdp_nn_symm_synapse.h | 2 +- models/urbanczik_synapse.h | 2 +- sli/sli_io.cc | 20 ++++++++++---------- sli/token.h | 2 +- sli/triedatum.cc | 2 +- sli/typechk.cc | 4 ++-- 8 files changed, 18 insertions(+), 18 deletions(-) diff --git a/libnestutil/stopwatch.h b/libnestutil/stopwatch.h index 410636f20d..6692afda98 100644 --- a/libnestutil/stopwatch.h +++ b/libnestutil/stopwatch.h @@ -281,7 +281,7 @@ nest::Stopwatch::get_timestamp() // * JuQueen (BG/Q) // * MacOS 10.9 struct timeval now; - gettimeofday( &now, ( struct timezone* ) nullptr ); + gettimeofday( &now, static_cast< struct timezone* >( nullptr ) ); return ( nest::Stopwatch::timestamp_t ) now.tv_usec + ( nest::Stopwatch::timestamp_t ) now.tv_sec * nest::Stopwatch::SECONDS; } diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 36d76eaefc..a9985f2d47 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -372,7 +372,7 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) + "), must have the same size." ); } - if ( this->n_receptors_() != old_n_receptors && has_connections_ ) + if ( this->n_receptors_() != old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " diff --git a/models/stdp_nn_symm_synapse.h b/models/stdp_nn_symm_synapse.h index b157bc4259..1fdf644883 100644 --- a/models/stdp_nn_symm_synapse.h +++ b/models/stdp_nn_symm_synapse.h @@ -331,7 +331,7 @@ stdp_nn_symm_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, updateValue< double >( d, names::Wmax, Wmax_ ); // check if weight_ and Wmax_ have the same sign - if ( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) != ( ( Wmax_ >= 0 ) - ( Wmax_ < 0 ) ) ) + if ( signbit( weight_) != signbit( Wmax_) ) { throw BadProperty( "Weight and Wmax must have same sign." ); } diff --git a/models/urbanczik_synapse.h b/models/urbanczik_synapse.h index dc833dce69..4313a035cb 100644 --- a/models/urbanczik_synapse.h +++ b/models/urbanczik_synapse.h @@ -312,7 +312,7 @@ urbanczik_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Co init_weight_ = weight_; // check if weight_ and Wmin_ has the same sign - if ( ( ( weight_ >= 0 ) - ( weight_ < 0 ) ) != ( ( Wmin_ >= 0 ) - ( Wmin_ < 0 ) ) ) + if ( signbit( weight_ ) != signbit( Wmax_ ) ) { throw BadProperty( "Weight and Wmin must have same sign." ); } diff --git a/sli/sli_io.cc b/sli/sli_io.cc index c8188bb67e..355bdaa9b6 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -267,7 +267,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const StringDatum* md = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr || md == nullptr ) + if ( sd == nullptr or md == nullptr ) { StringDatum const d; Token t1 = i->OStack.pick( 1 ); @@ -610,7 +610,7 @@ PrettyprintFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -642,7 +642,7 @@ FlushFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -682,7 +682,7 @@ EndlFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -710,7 +710,7 @@ EndsFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -735,7 +735,7 @@ EatwhiteFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( istreamdatum == nullptr or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -766,7 +766,7 @@ CloseistreamFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( istreamdatum == nullptr or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -855,7 +855,7 @@ SetwFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -906,7 +906,7 @@ SetprecisionFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -943,7 +943,7 @@ IOSFixedFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); diff --git a/sli/token.h b/sli/token.h index a48ff48d93..912ed355eb 100644 --- a/sli/token.h +++ b/sli/token.h @@ -341,7 +341,7 @@ class Token bool contains( const Datum& d ) const { - return ( p != nullptr ) && p->equals( &d ); + return ( p != nullptr ) and p->equals( &d ); } bool diff --git a/sli/triedatum.cc b/sli/triedatum.cc index 51a760eab6..be28bd56e7 100644 --- a/sli/triedatum.cc +++ b/sli/triedatum.cc @@ -36,5 +36,5 @@ TrieDatum::equals( Datum const* dat ) const const TrieDatum* fd = dynamic_cast< TrieDatum* >( const_cast< Datum* >( dat ) ); - return fd != nullptr && ( tree == fd->tree ); + return fd != nullptr and tree == fd->tree; } diff --git a/sli/typechk.cc b/sli/typechk.cc index 49a9301919..ed9df8434b 100644 --- a/sli/typechk.cc +++ b/sli/typechk.cc @@ -68,7 +68,7 @@ void TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const { assert( a.size() == 0 ); - if ( next == nullptr && alt == nullptr ) // Leaf node + if ( next == nullptr and alt == nullptr ) // Leaf node { a.push_back( func ); } @@ -92,7 +92,7 @@ TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const void TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl ) const { - if ( next == nullptr && alt == nullptr ) // Leaf node + if ( next == nullptr and alt == nullptr ) // Leaf node { // print type list then function for ( int i = tl.size() - 1; i >= 0; --i ) From 73278c100c74a3d1fde80af45adf982b6df533c5 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 11:11:56 +0200 Subject: [PATCH 069/150] Apply suggestions from code review Co-authored-by: Hans Ekkehard Plesser --- sli/slimath.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/slimath.cc b/sli/slimath.cc index f50b5f4930..dc3886d64c 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -1121,7 +1121,7 @@ OrFunction::execute( SLIInterpreter* i ) const BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); assert( op1 != NULL && op2 != NULL ); - op1->get() = ( op1->get() == true || op2->get() ); + op1->get() = ( op1->get() or op2->get() ); i->OStack.pop(); } From 73239a41ae050ba31673b2f41cf666c884471d1a Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 12:53:42 +0200 Subject: [PATCH 070/150] Unused imports --- models/ac_generator.cpp | 1 - models/aeif_cond_alpha.cpp | 4 ---- models/aeif_cond_alpha_multisynapse.cpp | 2 -- models/aeif_cond_beta_multisynapse.cpp | 2 -- models/aeif_cond_exp.cpp | 4 ---- models/aeif_psc_alpha.cpp | 4 ---- models/aeif_psc_delta.cpp | 4 ---- models/aeif_psc_delta_clopath.cpp | 4 ---- models/aeif_psc_exp.cpp | 4 ---- models/amat2_psc_exp.cpp | 5 ----- models/correlation_detector.cpp | 1 - models/correlomatrix_detector.cpp | 1 - models/correlospinmatrix_detector.cpp | 1 - models/dc_generator.cpp | 1 - models/gamma_sup_generator.cpp | 3 --- models/gif_cond_exp.cpp | 5 ----- models/gif_cond_exp_multisynapse.cpp | 4 ---- models/gif_psc_exp.cpp | 5 ----- models/gif_psc_exp_multisynapse.cpp | 5 ----- models/glif_cond.cpp | 3 --- models/glif_psc.cpp | 4 ---- models/hh_cond_beta_gap_traub.cpp | 6 ------ models/hh_cond_exp_traub.cpp | 8 -------- models/hh_psc_alpha.cpp | 7 ------- models/hh_psc_alpha_clopath.cpp | 7 ------- models/hh_psc_alpha_gap.cpp | 4 ---- models/iaf_chs_2007.cpp | 5 ----- models/iaf_chxk_2008.cpp | 6 ------ models/iaf_cond_alpha.cpp | 5 ----- models/iaf_cond_alpha_mc.cpp | 4 ---- models/iaf_cond_beta.cpp | 5 ----- models/iaf_cond_exp.cpp | 5 ----- models/iaf_cond_exp_sfa_rr.cpp | 5 ----- models/iaf_psc_alpha.cpp | 3 --- models/iaf_psc_alpha_canon.cpp | 3 --- models/iaf_psc_alpha_multisynapse.cpp | 2 -- models/iaf_psc_alpha_ps.cpp | 3 --- models/iaf_psc_delta.cpp | 3 --- models/iaf_psc_delta_ps.cpp | 3 --- models/iaf_psc_exp.cpp | 6 ------ models/iaf_psc_exp_htum.cpp | 5 ----- models/iaf_psc_exp_multisynapse.cpp | 4 ---- models/iaf_psc_exp_ps.cpp | 3 --- models/iaf_psc_exp_ps_lossless.cpp | 3 --- models/inhomogeneous_poisson_generator.cpp | 5 ----- models/izhikevich.cpp | 4 ---- models/mat2_psc_exp.cpp | 5 ----- models/modelsmodule.cpp | 7 ------- models/noise_generator.cpp | 1 - models/parrot_neuron.cpp | 6 ------ models/parrot_neuron_ps.cpp | 6 ------ models/pp_cond_exp_mc_urbanczik.cpp | 4 ---- models/pp_pop_psc_delta.cpp | 3 --- models/pp_psc_delta.cpp | 4 ---- models/siegert_neuron.cpp | 5 ----- models/sinusoidal_poisson_generator.cpp | 3 --- models/spike_recorder.cpp | 7 ------- models/spin_detector.cpp | 7 ------- models/stdp_synapse_hom.cpp | 1 - models/volume_transmitter.cpp | 6 ------ models/weight_recorder.cpp | 6 ------ nest/main.cpp | 2 -- nest/neststartup.cpp | 8 -------- nestkernel/common_synapse_properties.cpp | 1 - nestkernel/conn_builder.cpp | 1 - nestkernel/conn_builder_conngen.cpp | 2 -- nestkernel/conn_parameter.cpp | 1 - nestkernel/connection_manager.cpp | 3 --- nestkernel/device.cpp | 4 ---- nestkernel/dynamicloader.cpp | 1 - nestkernel/event.cpp | 1 - nestkernel/event_delivery_manager.cpp | 6 ------ nestkernel/io_manager.cpp | 4 ---- nestkernel/layer.cpp | 3 --- nestkernel/model_manager.cpp | 3 --- nestkernel/mpi_manager.cpp | 6 ------ nestkernel/music_manager.cpp | 10 ---------- nestkernel/nest.cpp | 1 - nestkernel/nestmodule.cpp | 6 ------ nestkernel/node.cpp | 1 - nestkernel/node_manager.cpp | 2 -- nestkernel/source_table.cpp | 1 - nestkernel/sp_manager.cpp | 1 - nestkernel/spatial.cpp | 1 - nestkernel/target_table_devices.cpp | 1 - nestkernel/vp_manager.cpp | 1 - sli/booldatum.cc | 1 - sli/datum.cc | 5 ----- sli/dict.cc | 1 - sli/filesystem.cc | 1 - sli/get_mem.c | 3 --- sli/interpret.cc | 7 ------- sli/parser.cc | 3 --- sli/processes.cc | 2 -- sli/puresli.cc | 2 -- sli/scanner.cc | 1 - sli/sli_io.cc | 6 ------ sli/sliactions.cc | 1 - sli/sliarray.cc | 3 --- sli/slicontrol.cc | 2 -- sli/slidata.cc | 1 - sli/slidict.cc | 2 -- sli/sliexceptions.cc | 3 --- sli/sligraphics.cc | 2 -- sli/slimath.cc | 3 --- sli/sliregexp.cc | 1 - sli/slistack.cc | 3 --- sli/slistartup.cc | 1 - sli/token.cc | 1 - sli/tokenarray.cc | 1 - 110 files changed, 379 deletions(-) diff --git a/models/ac_generator.cpp b/models/ac_generator.cpp index b1d81ce856..e25a1ca2a7 100644 --- a/models/ac_generator.cpp +++ b/models/ac_generator.cpp @@ -38,7 +38,6 @@ #include "dict.h" #include "dictutils.h" #include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index 38452412c4..733953a59b 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index ce05088cd1..c3b3ab68c4 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -39,8 +39,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest // template specialization must be placed in namespace diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index 9736ac5c95..de08e9a8e5 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -40,8 +40,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest // template specialization must be placed in namespace { diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index 9ced5680e1..25793f04c6 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index c4bd15cc15..5a5eea864b 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 8d5e94c812..3c45346fe6 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index 31aafd95b5..0422bf9391 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 04112300f1..f52940afcd 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -27,7 +27,6 @@ // C++ includes: #include #include -#include #include #include @@ -42,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/amat2_psc_exp.cpp b/models/amat2_psc_exp.cpp index 62cc7a2d38..8164f1685c 100644 --- a/models/amat2_psc_exp.cpp +++ b/models/amat2_psc_exp.cpp @@ -22,8 +22,6 @@ #include "amat2_psc_exp.h" -// C++ includes: -#include // Includes from libnestutil: #include "dict_util.h" @@ -35,10 +33,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/correlation_detector.cpp b/models/correlation_detector.cpp index 25fba71761..5205ae964e 100644 --- a/models/correlation_detector.cpp +++ b/models/correlation_detector.cpp @@ -25,7 +25,6 @@ // C++ includes: #include // for less #include // for bind2nd -#include // Includes from libnestutil: #include "compose.hpp" diff --git a/models/correlomatrix_detector.cpp b/models/correlomatrix_detector.cpp index c671788641..ef4f5a786f 100644 --- a/models/correlomatrix_detector.cpp +++ b/models/correlomatrix_detector.cpp @@ -25,7 +25,6 @@ // C++ includes: #include // for less #include // for bind2nd -#include // Includes from libnestutil: #include "compose.hpp" diff --git a/models/correlospinmatrix_detector.cpp b/models/correlospinmatrix_detector.cpp index 46c1a70017..0b4f3a8d6e 100644 --- a/models/correlospinmatrix_detector.cpp +++ b/models/correlospinmatrix_detector.cpp @@ -25,7 +25,6 @@ // C++ includes: #include #include -#include // Includes from libnestutil: #include "compose.hpp" diff --git a/models/dc_generator.cpp b/models/dc_generator.cpp index 1c1cd4aa80..dda66f131a 100644 --- a/models/dc_generator.cpp +++ b/models/dc_generator.cpp @@ -34,7 +34,6 @@ #include "dict.h" #include "dictutils.h" #include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/gamma_sup_generator.cpp b/models/gamma_sup_generator.cpp index 0adfa7a9af..994ac0baf8 100644 --- a/models/gamma_sup_generator.cpp +++ b/models/gamma_sup_generator.cpp @@ -24,7 +24,6 @@ // C++ includes: #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -35,10 +34,8 @@ #include "kernel_manager.h" // Includes from sli: -#include "datum.h" #include "dict.h" #include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index 248b76d8eb..0e61b43db8 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -26,9 +26,6 @@ // C++ includes: #include -#include -#include -#include // Includes from libnestutil: #include "compose.hpp" @@ -43,8 +40,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index c1966d08ee..fa620254b2 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -26,9 +26,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "compose.hpp" @@ -43,8 +41,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest diff --git a/models/gif_psc_exp.cpp b/models/gif_psc_exp.cpp index 94e6ca306a..f89cfffddf 100644 --- a/models/gif_psc_exp.cpp +++ b/models/gif_psc_exp.cpp @@ -22,9 +22,6 @@ #include "gif_psc_exp.h" -// C++ includes: -#include - // Includes from nestkernel: #include "exceptions.h" #include "kernel_manager.h" @@ -36,8 +33,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" #include "compose.hpp" #include "numerics.h" diff --git a/models/gif_psc_exp_multisynapse.cpp b/models/gif_psc_exp_multisynapse.cpp index 84c59b3c45..6a3d875a52 100644 --- a/models/gif_psc_exp_multisynapse.cpp +++ b/models/gif_psc_exp_multisynapse.cpp @@ -22,9 +22,6 @@ #include "gif_psc_exp_multisynapse.h" -// C++ includes: -#include - // Includes from libnestutil: #include "dict_util.h" #include "numerics.h" @@ -37,8 +34,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" #include "compose.hpp" #include "propagator_stability.h" diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 0b48ea9253..64bde3219c 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -40,9 +40,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" -#include "lockptrdatum.h" using namespace nest; diff --git a/models/glif_psc.cpp b/models/glif_psc.cpp index cbe7ddae00..ec63fa3f97 100644 --- a/models/glif_psc.cpp +++ b/models/glif_psc.cpp @@ -33,15 +33,11 @@ // Includes from nestkernel: #include "exceptions.h" #include "kernel_manager.h" -#include "name.h" #include "universal_data_logger_impl.h" // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" -#include "lockptrdatum.h" using namespace nest; diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index 97f6a29604..a49857aebf 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -28,14 +28,10 @@ // C++ includes: #include // in case we need isnan() // fabs #include -#include #include -#include // External includes: #include -#include -#include // Includes from libnestutil: #include "beta_normalization_factor.h" @@ -49,8 +45,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::hh_cond_beta_gap_traub > nest::hh_cond_beta_gap_traub::recordablesMap_; diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index 87f32e10f6..1b9a4fd5a5 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -27,14 +27,9 @@ // C++ includes: #include -#include -#include -#include // External includes: #include -#include -#include // Includes from libnestutil: #include "dict_util.h" @@ -46,10 +41,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::hh_cond_exp_traub > nest::hh_cond_exp_traub::recordablesMap_; diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index d2eddb4343..4f672f0fd8 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -27,25 +27,18 @@ // C++ includes: #include -#include -#include -#include // Includes from libnestutil: #include "dict_util.h" #include "numerics.h" // Includes from nestkernel: -#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::hh_psc_alpha > nest::hh_psc_alpha::recordablesMap_; diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index 02ec008e07..a4fc076a5a 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -27,25 +27,18 @@ // C++ includes: #include -#include -#include -#include // Includes from libnestutil: #include "dict_util.h" #include "numerics.h" // Includes from nestkernel: -#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::hh_psc_alpha_clopath > nest::hh_psc_alpha_clopath::recordablesMap_; diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index 362449ff56..67b717c9b9 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -28,9 +28,7 @@ // C++ includes: #include // in case we need isnan() // fabs #include -#include #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -44,8 +42,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::hh_psc_alpha_gap > nest::hh_psc_alpha_gap::recordablesMap_; diff --git a/models/iaf_chs_2007.cpp b/models/iaf_chs_2007.cpp index a46dcddcbf..69f2a82f7a 100644 --- a/models/iaf_chs_2007.cpp +++ b/models/iaf_chs_2007.cpp @@ -22,9 +22,6 @@ #include "iaf_chs_2007.h" -// C++ includes: -#include - // Includes from libnestutil: #include "dict_util.h" #include "numerics.h" @@ -37,8 +34,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_chxk_2008.cpp b/models/iaf_chxk_2008.cpp index 24dcffc469..a0b598905d 100644 --- a/models/iaf_chxk_2008.cpp +++ b/models/iaf_chxk_2008.cpp @@ -26,9 +26,6 @@ // C++ includes: #include -#include -#include -#include // Includes from libnestutil: #include "dict_util.h" @@ -40,10 +37,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index f6e12f3b22..a0dc062e0e 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -27,9 +27,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -41,10 +39,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index cd73b2baa3..71a98e954c 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -27,9 +27,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -43,8 +41,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Compartment name list diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index c7d88155d3..ddbf9a44d8 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -27,9 +27,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "beta_normalization_factor.h" @@ -42,10 +40,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index 4fe51d41bc..7e806e9440 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -26,9 +26,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -41,10 +39,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index b38ac19c1c..a023086f1a 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -27,9 +27,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -41,10 +39,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_alpha.cpp b/models/iaf_psc_alpha.cpp index e6cf6737c2..a6a4863cff 100644 --- a/models/iaf_psc_alpha.cpp +++ b/models/iaf_psc_alpha.cpp @@ -37,10 +37,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::RecordablesMap< nest::iaf_psc_alpha > nest::iaf_psc_alpha::recordablesMap_; diff --git a/models/iaf_psc_alpha_canon.cpp b/models/iaf_psc_alpha_canon.cpp index 7032a8d32b..ba492b934c 100644 --- a/models/iaf_psc_alpha_canon.cpp +++ b/models/iaf_psc_alpha_canon.cpp @@ -35,10 +35,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_alpha_multisynapse.cpp b/models/iaf_psc_alpha_multisynapse.cpp index 0a16644540..024f9c55b4 100644 --- a/models/iaf_psc_alpha_multisynapse.cpp +++ b/models/iaf_psc_alpha_multisynapse.cpp @@ -38,8 +38,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_alpha_ps.cpp b/models/iaf_psc_alpha_ps.cpp index be1f8b8076..d1653355f9 100644 --- a/models/iaf_psc_alpha_ps.cpp +++ b/models/iaf_psc_alpha_ps.cpp @@ -36,10 +36,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_delta.cpp b/models/iaf_psc_delta.cpp index 5f991e2cc2..0e393a33ab 100644 --- a/models/iaf_psc_delta.cpp +++ b/models/iaf_psc_delta.cpp @@ -37,10 +37,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/iaf_psc_delta_ps.cpp b/models/iaf_psc_delta_ps.cpp index 152486f1e4..65c0a9a3de 100644 --- a/models/iaf_psc_delta_ps.cpp +++ b/models/iaf_psc_delta_ps.cpp @@ -37,10 +37,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/iaf_psc_exp.cpp b/models/iaf_psc_exp.cpp index e6201d792c..a09b9b1a26 100644 --- a/models/iaf_psc_exp.cpp +++ b/models/iaf_psc_exp.cpp @@ -22,8 +22,6 @@ #include "iaf_psc_exp.h" -// C++ includes: -#include // Includes from libnestutil: #include "dict_util.h" @@ -31,17 +29,13 @@ #include "propagator_stability.h" // Includes from nestkernel: -#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "ring_buffer_impl.h" #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_exp_htum.cpp b/models/iaf_psc_exp_htum.cpp index 802a207620..88de457fb1 100644 --- a/models/iaf_psc_exp_htum.cpp +++ b/models/iaf_psc_exp_htum.cpp @@ -22,8 +22,6 @@ #include "iaf_psc_exp_htum.h" -// C++ includes: -#include // Includes from libnestutil: #include "dict_util.h" @@ -36,10 +34,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_exp_multisynapse.cpp b/models/iaf_psc_exp_multisynapse.cpp index 23e25a0d84..347050d323 100644 --- a/models/iaf_psc_exp_multisynapse.cpp +++ b/models/iaf_psc_exp_multisynapse.cpp @@ -22,8 +22,6 @@ #include "iaf_psc_exp_multisynapse.h" -// C++ includes: -#include // Includes from libnestutil: #include "dict_util.h" @@ -38,8 +36,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_exp_ps.cpp b/models/iaf_psc_exp_ps.cpp index 751e83b3ae..a076c9611b 100644 --- a/models/iaf_psc_exp_ps.cpp +++ b/models/iaf_psc_exp_ps.cpp @@ -37,10 +37,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/iaf_psc_exp_ps_lossless.cpp b/models/iaf_psc_exp_ps_lossless.cpp index afbefc3fea..c0c8a77f3a 100644 --- a/models/iaf_psc_exp_ps_lossless.cpp +++ b/models/iaf_psc_exp_ps_lossless.cpp @@ -35,11 +35,8 @@ #include "regula_falsi.h" // Includes from sli: -#include "arraydatum.h" #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- diff --git a/models/inhomogeneous_poisson_generator.cpp b/models/inhomogeneous_poisson_generator.cpp index c2b43df40c..fb1cfd9464 100644 --- a/models/inhomogeneous_poisson_generator.cpp +++ b/models/inhomogeneous_poisson_generator.cpp @@ -24,25 +24,20 @@ // C++ includes: #include -#include // Includes from libnestutil: -#include "dict_util.h" #include "numerics.h" // Includes from nestkernel: #include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" -#include "universal_data_logger_impl.h" // Includes from sli: #include "arraydatum.h" #include "booldatum.h" #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- diff --git a/models/izhikevich.cpp b/models/izhikevich.cpp index 5dd1710e11..11b47a2d27 100644 --- a/models/izhikevich.cpp +++ b/models/izhikevich.cpp @@ -30,16 +30,12 @@ #include "numerics.h" // Includes from nestkernel: -#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/mat2_psc_exp.cpp b/models/mat2_psc_exp.cpp index 772c4fc216..709670acf0 100644 --- a/models/mat2_psc_exp.cpp +++ b/models/mat2_psc_exp.cpp @@ -22,8 +22,6 @@ #include "mat2_psc_exp.h" -// C++ includes: -#include // Includes from libnestutil: #include "dict_util.h" @@ -35,10 +33,7 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Recordables map diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 1a9181d31c..2db4846c2f 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -22,9 +22,6 @@ #include "modelsmodule.h" -// Includes from nestkernel -#include "genericmodel_impl.h" - // Generated includes: #include "config.h" @@ -119,7 +116,6 @@ // Prototypes for synapses #include "bernoulli_synapse.h" #include "clopath_synapse.h" -#include "common_synapse_properties.h" #include "cont_delay_synapse.h" #include "cont_delay_synapse_impl.h" #include "diffusion_connection.h" @@ -149,9 +145,6 @@ #include "vogels_sprekeler_synapse.h" // Includes from nestkernel: -#include "common_synapse_properties.h" -#include "connector_model_impl.h" -#include "genericmodel.h" #include "kernel_manager.h" #include "model.h" #include "model_manager_impl.h" diff --git a/models/noise_generator.cpp b/models/noise_generator.cpp index 6792064db9..9838e8424d 100644 --- a/models/noise_generator.cpp +++ b/models/noise_generator.cpp @@ -37,7 +37,6 @@ #include "dict.h" #include "dictutils.h" #include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/parrot_neuron.cpp b/models/parrot_neuron.cpp index fd6962372a..853966f069 100644 --- a/models/parrot_neuron.cpp +++ b/models/parrot_neuron.cpp @@ -23,9 +23,6 @@ #include "parrot_neuron.h" -// C++ includes: -#include - // Includes from libnestutil: #include "numerics.h" @@ -35,10 +32,7 @@ #include "kernel_manager.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/parrot_neuron_ps.cpp b/models/parrot_neuron_ps.cpp index d5381b740e..3969ac8fe5 100644 --- a/models/parrot_neuron_ps.cpp +++ b/models/parrot_neuron_ps.cpp @@ -22,9 +22,6 @@ #include "parrot_neuron_ps.h" -// C++ includes: -#include - // Includes from libnestutil: #include "numerics.h" @@ -34,10 +31,7 @@ #include "kernel_manager.h" // Includes from sli: -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index b3d81a4bdc..da7365a144 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -27,9 +27,7 @@ // C++ includes: #include -#include #include -#include // Includes from libnestutil: #include "numerics.h" @@ -42,8 +40,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Compartment name list diff --git a/models/pp_pop_psc_delta.cpp b/models/pp_pop_psc_delta.cpp index da9fa5ed4a..e782c1c840 100644 --- a/models/pp_pop_psc_delta.cpp +++ b/models/pp_pop_psc_delta.cpp @@ -23,7 +23,6 @@ #include "pp_pop_psc_delta.h" // C++ includes: -#include #include // Includes from libnestutil: @@ -39,8 +38,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/pp_psc_delta.cpp b/models/pp_psc_delta.cpp index a89354e025..44418f7df2 100644 --- a/models/pp_psc_delta.cpp +++ b/models/pp_psc_delta.cpp @@ -27,8 +27,6 @@ #include "pp_psc_delta.h" -// C++ includes: -#include // Includes from libnestutil: #include "compose.hpp" @@ -43,8 +41,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/siegert_neuron.cpp b/models/siegert_neuron.cpp index 7fd0a31543..103cb253e1 100644 --- a/models/siegert_neuron.cpp +++ b/models/siegert_neuron.cpp @@ -27,9 +27,6 @@ // C++ includes: #include // in case we need isnan() // fabs #include -#include -#include -#include #include // Includes from libnestutil: @@ -44,8 +41,6 @@ // Includes from sli: #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" struct my_params { diff --git a/models/sinusoidal_poisson_generator.cpp b/models/sinusoidal_poisson_generator.cpp index 769b2beee9..23d2eca8ae 100644 --- a/models/sinusoidal_poisson_generator.cpp +++ b/models/sinusoidal_poisson_generator.cpp @@ -25,7 +25,6 @@ // C++ includes: #include -#include // Includes from libnestutil: #include "dict_util.h" @@ -38,12 +37,10 @@ #include "universal_data_logger_impl.h" // Includes from sli: -#include "arraydatum.h" #include "booldatum.h" #include "dict.h" #include "dictutils.h" #include "doubledatum.h" -#include "integerdatum.h" namespace nest { diff --git a/models/spike_recorder.cpp b/models/spike_recorder.cpp index 5f9326785e..507489239f 100644 --- a/models/spike_recorder.cpp +++ b/models/spike_recorder.cpp @@ -22,24 +22,17 @@ #include "spike_recorder.h" -// C++ includes: -#include // Includes from libnestutil: #include "compose.hpp" -#include "dict_util.h" -#include "logging.h" // Includes from nestkernel: #include "event_delivery_manager_impl.h" #include "kernel_manager.h" // Includes from sli: -#include "arraydatum.h" #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::spike_recorder::spike_recorder() : RecordingDevice() diff --git a/models/spin_detector.cpp b/models/spin_detector.cpp index 7740a585b1..af613b8f83 100644 --- a/models/spin_detector.cpp +++ b/models/spin_detector.cpp @@ -22,24 +22,17 @@ #include "spin_detector.h" -// C++ includes: -#include // Includes from libnestutil: #include "compose.hpp" -#include "dict_util.h" -#include "logging.h" // Includes from nestkernel: #include "event_delivery_manager_impl.h" #include "kernel_manager.h" // Includes from sli: -#include "arraydatum.h" #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" nest::spin_detector::spin_detector() : last_in_node_id_( 0 ) diff --git a/models/stdp_synapse_hom.cpp b/models/stdp_synapse_hom.cpp index a2506bb17a..ab3853e791 100644 --- a/models/stdp_synapse_hom.cpp +++ b/models/stdp_synapse_hom.cpp @@ -25,7 +25,6 @@ // Includes from nestkernel: #include "common_synapse_properties.h" #include "connector_model.h" -#include "event.h" // Includes from sli: #include "dictdatum.h" diff --git a/models/volume_transmitter.cpp b/models/volume_transmitter.cpp index 07d1c18006..f9184b8ee5 100644 --- a/models/volume_transmitter.cpp +++ b/models/volume_transmitter.cpp @@ -22,8 +22,6 @@ #include "volume_transmitter.h" -// C++ includes: -#include // Includes from nestkernel: #include "connector_base.h" @@ -35,11 +33,7 @@ #include "dict_util.h" // Includes from sli: -#include "arraydatum.h" -#include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" /* ---------------------------------------------------------------- * Default constructor defining default parameters diff --git a/models/weight_recorder.cpp b/models/weight_recorder.cpp index 0c2d13bf8f..35a4f5a962 100644 --- a/models/weight_recorder.cpp +++ b/models/weight_recorder.cpp @@ -22,13 +22,9 @@ #include "weight_recorder.h" -// C++ includes: -#include // Includes from libnestutil: #include "compose.hpp" -#include "dict_util.h" -#include "logging.h" // Includes from nestkernel: #include "event_delivery_manager_impl.h" @@ -40,8 +36,6 @@ #include "arraydatum.h" #include "dict.h" #include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" // record time, node ID, weight and receiver node ID nest::weight_recorder::weight_recorder() diff --git a/nest/main.cpp b/nest/main.cpp index c3771e39ce..a10eaf3518 100644 --- a/nest/main.cpp +++ b/nest/main.cpp @@ -20,8 +20,6 @@ * */ -// Generated includes: -#include "config.h" // Includes from nest: #include "neststartup.h" diff --git a/nest/neststartup.cpp b/nest/neststartup.cpp index 3707984d62..973da183ff 100644 --- a/nest/neststartup.cpp +++ b/nest/neststartup.cpp @@ -22,29 +22,21 @@ #include "neststartup.h" -// C++ includes: -#include // Generated includes: #include "config.h" #include "static_modules.h" // Includes from libnestutil: -#include "logging.h" #include "logging_event.h" // Includes from nestkernel: #include "dynamicloader.h" -#include "exceptions.h" -#include "genericmodel_impl.h" #include "kernel_manager.h" -#include "model_manager_impl.h" #include "nest.h" #include "nestmodule.h" // Includes from sli: -#include "dict.h" -#include "dictdatum.h" #include "filesystem.h" #include "interpret.h" #include "oosupport.h" diff --git a/nestkernel/common_synapse_properties.cpp b/nestkernel/common_synapse_properties.cpp index 69502b1d55..6ba06dd13c 100644 --- a/nestkernel/common_synapse_properties.cpp +++ b/nestkernel/common_synapse_properties.cpp @@ -25,7 +25,6 @@ // Includes from nestkernel: #include "connector_model.h" #include "nest_timeconverter.h" -#include "nest_types.h" #include "node.h" // Includes from sli: diff --git a/nestkernel/conn_builder.cpp b/nestkernel/conn_builder.cpp index 7e70c166bd..147a599391 100644 --- a/nestkernel/conn_builder.cpp +++ b/nestkernel/conn_builder.cpp @@ -36,7 +36,6 @@ // Includes from sli: #include "dict.h" -#include "fdstream.h" #include "name.h" nest::ConnBuilder::ConnBuilder( NodeCollectionPTR sources, diff --git a/nestkernel/conn_builder_conngen.cpp b/nestkernel/conn_builder_conngen.cpp index d6f2f6119f..59ddef3cd0 100644 --- a/nestkernel/conn_builder_conngen.cpp +++ b/nestkernel/conn_builder_conngen.cpp @@ -20,8 +20,6 @@ * */ -#include "conn_builder_conngen.h" - #ifdef HAVE_LIBNEUROSIM // Includes from nestkernel: diff --git a/nestkernel/conn_parameter.cpp b/nestkernel/conn_parameter.cpp index 9cbcd24fd4..6eb3d58b73 100644 --- a/nestkernel/conn_parameter.cpp +++ b/nestkernel/conn_parameter.cpp @@ -30,7 +30,6 @@ #include "arraydatum.h" #include "doubledatum.h" #include "integerdatum.h" -#include "tokenutils.h" nest::ConnParameter* nest::ConnParameter::create( const Token& t, const size_t nthreads ) diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index e605efff25..1d6d45afdc 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -22,9 +22,6 @@ #include "connection_manager.h" -// Generated includes: -#include "config.h" - // C++ includes: #include #include diff --git a/nestkernel/device.cpp b/nestkernel/device.cpp index d248e84e11..a142e66d73 100644 --- a/nestkernel/device.cpp +++ b/nestkernel/device.cpp @@ -22,14 +22,10 @@ #include "device.h" -// C++ includes: -#include -#include // Includes from nestkernel: #include "exceptions.h" #include "nest_names.h" -#include "node.h" // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/dynamicloader.cpp b/nestkernel/dynamicloader.cpp index 009f9e2d3a..c411d4c9d4 100644 --- a/nestkernel/dynamicloader.cpp +++ b/nestkernel/dynamicloader.cpp @@ -47,7 +47,6 @@ #include "model.h" // Includes from sli: -#include "integerdatum.h" #include "interpret.h" #include "stringdatum.h" diff --git a/nestkernel/event.cpp b/nestkernel/event.cpp index 109c094833..f43c959caa 100644 --- a/nestkernel/event.cpp +++ b/nestkernel/event.cpp @@ -31,7 +31,6 @@ // Includes from nestkernel: #include "kernel_manager.h" -#include "node.h" namespace nest { diff --git a/nestkernel/event_delivery_manager.cpp b/nestkernel/event_delivery_manager.cpp index 6776578d5e..95d0d30c68 100644 --- a/nestkernel/event_delivery_manager.cpp +++ b/nestkernel/event_delivery_manager.cpp @@ -24,18 +24,12 @@ // C++ includes: #include // rotate -#include #include // accumulate -// Includes from libnestutil: -#include "logging.h" - // Includes from nestkernel: #include "connection_manager.h" #include "connection_manager_impl.h" -#include "event_delivery_manager_impl.h" #include "kernel_manager.h" -#include "mpi_manager_impl.h" #include "send_buffer_position.h" #include "source.h" #include "vp_manager.h" diff --git a/nestkernel/io_manager.cpp b/nestkernel/io_manager.cpp index 714c1d3e40..4c21d16b7b 100644 --- a/nestkernel/io_manager.cpp +++ b/nestkernel/io_manager.cpp @@ -22,13 +22,9 @@ #include "io_manager.h" -// Generated includes: -#include "config.h" - // C includes: #include #include -#include // C++ includes: #include diff --git a/nestkernel/layer.cpp b/nestkernel/layer.cpp index 27e817d250..9614ccde39 100644 --- a/nestkernel/layer.cpp +++ b/nestkernel/layer.cpp @@ -34,11 +34,8 @@ #include "integerdatum.h" // Includes from spatial: -#include "connection_creator_impl.h" #include "free_layer.h" #include "grid_layer.h" -#include "layer_impl.h" -#include "mask_impl.h" #include "spatial.h" namespace nest diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 041de0d811..7d1297020c 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -32,11 +32,8 @@ // Includes from nestkernel: #include "connector_model_impl.h" -#include "genericmodel_impl.h" #include "kernel_manager.h" -#include "model_manager_impl.h" #include "proxynode.h" -#include "vp_manager_impl.h" namespace nest diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index d9e9528ef3..bb6747b65b 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -22,18 +22,12 @@ #include "mpi_manager.h" -// C++ includes: -#include -#include // Includes from libnestutil: -#include "compose.hpp" -#include "logging.h" #include "stopwatch.h" // Includes from nestkernel: #include "kernel_manager.h" -#include "mpi_manager_impl.h" #include "nest_types.h" // Includes from sli: diff --git a/nestkernel/music_manager.cpp b/nestkernel/music_manager.cpp index 416f1c4018..46c79ce0f0 100644 --- a/nestkernel/music_manager.cpp +++ b/nestkernel/music_manager.cpp @@ -29,16 +29,6 @@ #endif #endif -// C++ includes: -//#include - -// Includes from libnestutil: -#include "compose.hpp" -//#include "logging.h" - -// Includes from nestkernel: -#include "kernel_manager.h" - // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/nest.cpp b/nestkernel/nest.cpp index 5fa567eee6..47af63b5eb 100644 --- a/nestkernel/nest.cpp +++ b/nestkernel/nest.cpp @@ -28,7 +28,6 @@ // Includes from nestkernel: #include "exceptions.h" #include "kernel_manager.h" -#include "mpi_manager_impl.h" #include "parameter.h" // Includes from sli: diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index c4b6cdacf5..504e7bc10c 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -24,17 +24,13 @@ // C++ includes: #include -#include // Includes from libnestutil: #include "logging.h" // Includes from nestkernel: #include "conn_builder.h" -#include "conn_builder_conngen.h" -#include "connection_creator_impl.h" #include "connection_manager_impl.h" -#include "free_layer.h" #include "genericmodel.h" #include "grid_layer.h" #include "grid_mask.h" @@ -43,7 +39,6 @@ #include "layer_impl.h" #include "mask.h" #include "mask_impl.h" -#include "model_manager_impl.h" #include "nest.h" #include "nest_datums.h" #include "nest_types.h" @@ -56,7 +51,6 @@ #include "arraydatum.h" #include "booldatum.h" #include "doubledatum.h" -#include "integerdatum.h" #include "interpret.h" #include "sliexceptions.h" #include "stringdatum.h" diff --git a/nestkernel/node.cpp b/nestkernel/node.cpp index 0a5c154638..25725a7987 100644 --- a/nestkernel/node.cpp +++ b/nestkernel/node.cpp @@ -31,7 +31,6 @@ #include "kernel_manager.h" // Includes from sli: -#include "arraydatum.h" #include "dictutils.h" #include "namedatum.h" diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index 7ce920c466..b0ddbe0a33 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -30,8 +30,6 @@ #include "logging.h" // Includes from nestkernel: -#include "event_delivery_manager.h" -#include "genericmodel.h" #include "kernel_manager.h" #include "model.h" #include "model_manager_impl.h" diff --git a/nestkernel/source_table.cpp b/nestkernel/source_table.cpp index ff1aba3846..dda02e4b16 100644 --- a/nestkernel/source_table.cpp +++ b/nestkernel/source_table.cpp @@ -24,7 +24,6 @@ #include // Includes from nestkernel: -#include "connection_manager.h" #include "connection_manager_impl.h" #include "kernel_manager.h" #include "mpi_manager_impl.h" diff --git a/nestkernel/sp_manager.cpp b/nestkernel/sp_manager.cpp index 1c4b0497f8..50f4667695 100644 --- a/nestkernel/sp_manager.cpp +++ b/nestkernel/sp_manager.cpp @@ -34,7 +34,6 @@ // Includes from nestkernel: #include "conn_builder.h" -#include "conn_parameter.h" #include "connector_base.h" #include "connector_model.h" #include "kernel_manager.h" diff --git a/nestkernel/spatial.cpp b/nestkernel/spatial.cpp index 20edc85161..57a9fabc92 100644 --- a/nestkernel/spatial.cpp +++ b/nestkernel/spatial.cpp @@ -23,7 +23,6 @@ #include "spatial.h" // C++ includes: -#include #include // Includes from libnestutil: diff --git a/nestkernel/target_table_devices.cpp b/nestkernel/target_table_devices.cpp index 5035ce8380..1f6f2ad23f 100644 --- a/nestkernel/target_table_devices.cpp +++ b/nestkernel/target_table_devices.cpp @@ -23,7 +23,6 @@ // Includes from nestkernel: #include "connector_base.h" #include "kernel_manager.h" -#include "target_table_devices_impl.h" #include "vp_manager_impl.h" nest::TargetTableDevices::TargetTableDevices() diff --git a/nestkernel/vp_manager.cpp b/nestkernel/vp_manager.cpp index 690b2ff905..52a32cbf8e 100644 --- a/nestkernel/vp_manager.cpp +++ b/nestkernel/vp_manager.cpp @@ -28,7 +28,6 @@ // Includes from nestkernel: #include "kernel_manager.h" #include "mpi_manager.h" -#include "mpi_manager_impl.h" #include "vp_manager_impl.h" // Includes from sli: diff --git a/sli/booldatum.cc b/sli/booldatum.cc index baa6d2e37f..3a468c54cd 100644 --- a/sli/booldatum.cc +++ b/sli/booldatum.cc @@ -24,7 +24,6 @@ // Includes from sli: #include "name.h" -#include "token.h" sli::pool BoolDatum::memory( sizeof( BoolDatum ), 1024, 1 ); diff --git a/sli/datum.cc b/sli/datum.cc index bc6cceb346..0ca4007087 100644 --- a/sli/datum.cc +++ b/sli/datum.cc @@ -23,12 +23,7 @@ #include "datum.h" // Includes from sli: -#include "arraydatum.h" -#include "booldatum.h" #include "dictdatum.h" -#include "dictutils.h" -#include "doubledatum.h" -#include "integerdatum.h" #include "stringdatum.h" #include "token.h" diff --git a/sli/dict.cc b/sli/dict.cc index 34c744c67c..5cad54bcc9 100644 --- a/sli/dict.cc +++ b/sli/dict.cc @@ -24,7 +24,6 @@ // C++ includes: #include -#include #include #include #include diff --git a/sli/filesystem.cc b/sli/filesystem.cc index bfb8c28c7e..239eb65126 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -27,7 +27,6 @@ #include #include #include -#include #include // C++ includes: diff --git a/sli/get_mem.c b/sli/get_mem.c index 9818210e67..67aa22b5c5 100644 --- a/sli/get_mem.c +++ b/sli/get_mem.c @@ -20,9 +20,6 @@ * */ -// Generated includes: -#include "config.h" - // C includes: #include diff --git a/sli/interpret.cc b/sli/interpret.cc index f04b3cd05e..4cfe76f869 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -31,19 +31,14 @@ #include #include #include -#include #include #include -// Generated includes: -#include "config.h" - // Includes from libnestutil: #include "compose.hpp" #include "numerics.h" // Includes from sli: -#include "booldatum.h" #include "dictdatum.h" #include "dictstack.h" #include "dictutils.h" @@ -54,9 +49,7 @@ #include "iostreamdatum.h" #include "namedatum.h" #include "parser.h" -#include "scanner.h" #include "stringdatum.h" -#include "tokenutils.h" #include "triedatum.h" // This function is the only interface to the driver program diff --git a/sli/parser.cc b/sli/parser.cc index 8a0dce6a2a..6006fb87eb 100644 --- a/sli/parser.cc +++ b/sli/parser.cc @@ -26,14 +26,11 @@ #include "parser.h" -// Generated includes: -#include "config.h" // Includes from sli: #include "arraydatum.h" #include "namedatum.h" #include "scanner.h" -#include "symboldatum.h" /*****************************************************************/ /* parse */ diff --git a/sli/processes.cc b/sli/processes.cc index 9f0fffdcf2..b58a454661 100644 --- a/sli/processes.cc +++ b/sli/processes.cc @@ -32,7 +32,6 @@ // C++ includes: #include -#include #include #include #include @@ -56,7 +55,6 @@ #include "namedatum.h" #include "sliexceptions.h" #include "stringdatum.h" -#include "tokenutils.h" // sstream has functions std::?stringstream diff --git a/sli/puresli.cc b/sli/puresli.cc index 83f6b69a72..13a4d85bd6 100644 --- a/sli/puresli.cc +++ b/sli/puresli.cc @@ -30,14 +30,12 @@ // Includes from sli: #include "filesystem.h" #include "gnureadline.h" -#include "integerdatum.h" #include "interpret.h" #include "oosupport.h" #include "processes.h" #include "sliarray.h" #include "sliregexp.h" #include "slistartup.h" -#include "tokenutils.h" int main( int argc, char* argv[] ) diff --git a/sli/scanner.cc b/sli/scanner.cc index d819e68a30..71fa92c370 100644 --- a/sli/scanner.cc +++ b/sli/scanner.cc @@ -36,7 +36,6 @@ #include "integerdatum.h" #include "namedatum.h" #include "stringdatum.h" -#include "symboldatum.h" /*************************************************************************/ /** Scanner (implemented as a DFA) */ diff --git a/sli/sli_io.cc b/sli/sli_io.cc index 3fb2943646..c29acaba58 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -27,25 +27,19 @@ #include "sli_io.h" // C++ includes: -#include -#include #include #include -#include // Generated includes: #include "config.h" // Includes from sli: -#include "arraydatum.h" #include "dictstack.h" #include "doubledatum.h" #include "fdstream.h" #include "integerdatum.h" #include "iostreamdatum.h" -#include "namedatum.h" #include "stringdatum.h" -#include "tokenutils.h" // sstream has functions std::?stringstream // strstream has functions std::?strstream diff --git a/sli/sliactions.cc b/sli/sliactions.cc index 8b722fc9f8..075086f9c5 100644 --- a/sli/sliactions.cc +++ b/sli/sliactions.cc @@ -33,7 +33,6 @@ #include "functiondatum.h" #include "integerdatum.h" #include "interpret.h" -#include "iostreamdatum.h" #include "namedatum.h" #include "triedatum.h" diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 0571d0fc85..f25fc11956 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -30,9 +30,6 @@ #include #include -// Generated includes: -#include "config.h" - // Includes from libnestutil: #include "numerics.h" diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index 72f73a9735..d6d003c770 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -28,7 +28,6 @@ // C includes: #include -#include #include #include #include @@ -47,7 +46,6 @@ #include "arraydatum.h" #include "booldatum.h" #include "dictstack.h" -#include "doubledatum.h" #include "functiondatum.h" #include "integerdatum.h" #include "iostreamdatum.h" diff --git a/sli/slidata.cc b/sli/slidata.cc index 546d14ac74..236bcc4311 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -38,7 +38,6 @@ #include "integerdatum.h" #include "namedatum.h" #include "stringdatum.h" -#include "tokenutils.h" /** @BeginDocumentation Name: allocations - Return the number of array reallocations. diff --git a/sli/slidict.cc b/sli/slidict.cc index def7bcf923..867fb6056d 100644 --- a/sli/slidict.cc +++ b/sli/slidict.cc @@ -26,8 +26,6 @@ #include "slidict.h" -// C++ includes: -#include // Includes from sli: #include "arraydatum.h" diff --git a/sli/sliexceptions.cc b/sli/sliexceptions.cc index d5bc0db2e3..bee4a13abf 100644 --- a/sli/sliexceptions.cc +++ b/sli/sliexceptions.cc @@ -25,9 +25,6 @@ // C++ includes: #include -// Generated includes: -#include "config.h" - // Includes from sli: #include "interpret.h" diff --git a/sli/sligraphics.cc b/sli/sligraphics.cc index 7b1c6c9a18..c0c2754c95 100644 --- a/sli/sligraphics.cc +++ b/sli/sligraphics.cc @@ -28,11 +28,9 @@ #include // Includes from sli: -#include "aggregatedatum.h" #include "arraydatum.h" #include "fdstream.h" #include "integerdatum.h" -#include "numericdatum.h" #include "stringdatum.h" diff --git a/sli/slimath.cc b/sli/slimath.cc index 101b196522..dd22ce59e7 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -29,14 +29,11 @@ // C++ includes: #include -// Generated includes: -#include "config.h" // Includes from sli: #include "booldatum.h" #include "doubledatum.h" #include "integerdatum.h" -#include "namedatum.h" #include "stringdatum.h" diff --git a/sli/sliregexp.cc b/sli/sliregexp.cc index d84a5d7b84..0d9d0d9eae 100644 --- a/sli/sliregexp.cc +++ b/sli/sliregexp.cc @@ -28,7 +28,6 @@ // Includes from sli: #include "arraydatum.h" #include "dictdatum.h" -#include "doubledatum.h" #include "integerdatum.h" #include "lockptrdatum.h" #include "stringdatum.h" diff --git a/sli/slistack.cc b/sli/slistack.cc index 0b896e5051..f22228c461 100644 --- a/sli/slistack.cc +++ b/sli/slistack.cc @@ -26,9 +26,6 @@ #include "slistack.h" -// C++ includes: -#include - // Includes from sli: #include "arraydatum.h" #include "integerdatum.h" diff --git a/sli/slistartup.cc b/sli/slistartup.cc index 3121d45fc4..46eeaae6f4 100644 --- a/sli/slistartup.cc +++ b/sli/slistartup.cc @@ -40,7 +40,6 @@ #include "integerdatum.h" #include "interpret.h" #include "iostreamdatum.h" -#include "namedatum.h" #include "stringdatum.h" // Access to environement variables. diff --git a/sli/token.cc b/sli/token.cc index 7b1c64688c..0229a4d455 100644 --- a/sli/token.cc +++ b/sli/token.cc @@ -32,7 +32,6 @@ #include "doubledatum.h" #include "integerdatum.h" #include "name.h" -#include "namedatum.h" #include "stringdatum.h" #include "tokenarray.h" #include "tokenutils.h" diff --git a/sli/tokenarray.cc b/sli/tokenarray.cc index 92e9c2f73a..3f098c5cab 100644 --- a/sli/tokenarray.cc +++ b/sli/tokenarray.cc @@ -26,7 +26,6 @@ #include "doubledatum.h" #include "integerdatum.h" #include "stringdatum.h" -#include "tokenutils.h" const TokenArray& From 3852d4cee479c3c09a5a8e7e575d87cea20ea0f1 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 12:56:59 +0200 Subject: [PATCH 071/150] Applied clang-format conforming formatting --- nestkernel/event_delivery_manager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/event_delivery_manager.cpp b/nestkernel/event_delivery_manager.cpp index 95d0d30c68..fe467c0571 100644 --- a/nestkernel/event_delivery_manager.cpp +++ b/nestkernel/event_delivery_manager.cpp @@ -24,7 +24,7 @@ // C++ includes: #include // rotate -#include // accumulate +#include // accumulate // Includes from nestkernel: #include "connection_manager.h" From 48fb765015ee652aba1902406c45cf647450caec Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 13:20:45 +0200 Subject: [PATCH 072/150] Fixed unintentional renaming of file --- sli/{sli/lockptrdatum.h => dictstack.h} | 0 sli/lockptrdatum.h | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename sli/{sli/lockptrdatum.h => dictstack.h} (100%) diff --git a/sli/sli/lockptrdatum.h b/sli/dictstack.h similarity index 100% rename from sli/sli/lockptrdatum.h rename to sli/dictstack.h diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index 39ee4f8b82..b2bf0f911d 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -106,7 +106,7 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > TypedDatum::operator= is called. The TypedDatum = is simply return *this. */ - // lockPTRDatum& operator=(const lockPTRDatum&) + lockPTRDatum& operator=(const lockPTRDatum&) /* operator== lockPTRDatum should only use the equals method for equality testing. From 73c1edb5bbe1e9598382225b680b4114c54b44f1 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 13:42:05 +0200 Subject: [PATCH 073/150] Applied clang-format conforming formatting --- sli/dictstack.h | 2 +- sli/lockptrdatum.h | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/sli/dictstack.h b/sli/dictstack.h index 73baca4d0e..56977e70ee 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -335,7 +335,7 @@ class DictionaryStack * The Token is moved. */ void basedef_move( const Name& n, Token& t ); - + void pop( void ); diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index b2bf0f911d..6220ddf3d0 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -106,15 +106,15 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > TypedDatum::operator= is called. The TypedDatum = is simply return *this. */ - lockPTRDatum& operator=(const lockPTRDatum&) - - /* operator== - lockPTRDatum should only use the equals method for equality testing. - Thus, the inherited lockPTR::operator== is made private. No - implementation is defined. - */ -private: - bool operator==( lockPTR< D >& ); + lockPTRDatum< D, sli >& operator=( const lockPTRDatum< D, sli >& ) + + /* operator== + lockPTRDatum should only use the equals method for equality testing. + Thus, the inherited lockPTR::operator== is made private. No + implementation is defined. + */ + private : bool + operator==( lockPTR< D >& ); }; /* equals(const Datum* datum) From b164be5360de0ec967e7edc1d543efafbb5c6c3b Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 14:05:10 +0200 Subject: [PATCH 074/150] Applied clang-format v13 instead of v15 --- sli/lockptrdatum.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index 6220ddf3d0..b72ea5fadb 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -113,8 +113,8 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > Thus, the inherited lockPTR::operator== is made private. No implementation is defined. */ - private : bool - operator==( lockPTR< D >& ); +private: + bool operator==( lockPTR< D >& ); }; /* equals(const Datum* datum) From 365b2cfbe5161285555e4bee9b88acbd21bd2352 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 14:43:16 +0200 Subject: [PATCH 075/150] Added back imports of pure implementation headers --- models/hh_psc_alpha.cpp | 1 + models/hh_psc_alpha_clopath.cpp | 1 + models/inhomogeneous_poisson_generator.cpp | 1 + models/izhikevich.cpp | 1 + models/modelsmodule.cpp | 7 +++++++ nestkernel/layer.cpp | 3 +++ nestkernel/model_manager.cpp | 3 +++ nestkernel/vp_manager.cpp | 1 + 8 files changed, 18 insertions(+) diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index 4f672f0fd8..73920cd082 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -33,6 +33,7 @@ #include "numerics.h" // Includes from nestkernel: +#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index a4fc076a5a..1c3ff530c7 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -33,6 +33,7 @@ #include "numerics.h" // Includes from nestkernel: +#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" diff --git a/models/inhomogeneous_poisson_generator.cpp b/models/inhomogeneous_poisson_generator.cpp index fb1cfd9464..ec909846f1 100644 --- a/models/inhomogeneous_poisson_generator.cpp +++ b/models/inhomogeneous_poisson_generator.cpp @@ -32,6 +32,7 @@ #include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" +#include "universal_data_logger_impl.h" // Includes from sli: #include "arraydatum.h" diff --git a/models/izhikevich.cpp b/models/izhikevich.cpp index 11b47a2d27..627952671a 100644 --- a/models/izhikevich.cpp +++ b/models/izhikevich.cpp @@ -30,6 +30,7 @@ #include "numerics.h" // Includes from nestkernel: +#include "event_delivery_manager_impl.h" #include "exceptions.h" #include "kernel_manager.h" #include "universal_data_logger_impl.h" diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 2db4846c2f..1a9181d31c 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -22,6 +22,9 @@ #include "modelsmodule.h" +// Includes from nestkernel +#include "genericmodel_impl.h" + // Generated includes: #include "config.h" @@ -116,6 +119,7 @@ // Prototypes for synapses #include "bernoulli_synapse.h" #include "clopath_synapse.h" +#include "common_synapse_properties.h" #include "cont_delay_synapse.h" #include "cont_delay_synapse_impl.h" #include "diffusion_connection.h" @@ -145,6 +149,9 @@ #include "vogels_sprekeler_synapse.h" // Includes from nestkernel: +#include "common_synapse_properties.h" +#include "connector_model_impl.h" +#include "genericmodel.h" #include "kernel_manager.h" #include "model.h" #include "model_manager_impl.h" diff --git a/nestkernel/layer.cpp b/nestkernel/layer.cpp index 9614ccde39..27e817d250 100644 --- a/nestkernel/layer.cpp +++ b/nestkernel/layer.cpp @@ -34,8 +34,11 @@ #include "integerdatum.h" // Includes from spatial: +#include "connection_creator_impl.h" #include "free_layer.h" #include "grid_layer.h" +#include "layer_impl.h" +#include "mask_impl.h" #include "spatial.h" namespace nest diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 7d1297020c..041de0d811 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -32,8 +32,11 @@ // Includes from nestkernel: #include "connector_model_impl.h" +#include "genericmodel_impl.h" #include "kernel_manager.h" +#include "model_manager_impl.h" #include "proxynode.h" +#include "vp_manager_impl.h" namespace nest diff --git a/nestkernel/vp_manager.cpp b/nestkernel/vp_manager.cpp index 52a32cbf8e..690b2ff905 100644 --- a/nestkernel/vp_manager.cpp +++ b/nestkernel/vp_manager.cpp @@ -28,6 +28,7 @@ // Includes from nestkernel: #include "kernel_manager.h" #include "mpi_manager.h" +#include "mpi_manager_impl.h" #include "vp_manager_impl.h" // Includes from sli: From c97f25945a4ee108206926f4f5002f6b2d39d702 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 14:52:01 +0200 Subject: [PATCH 076/150] Reverting any changes that have been done to the operator== part of lockptrdatum.h --- sli/lockptrdatum.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index b72ea5fadb..63378e749d 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -108,11 +108,11 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > */ lockPTRDatum< D, sli >& operator=( const lockPTRDatum< D, sli >& ) - /* operator== - lockPTRDatum should only use the equals method for equality testing. - Thus, the inherited lockPTR::operator== is made private. No - implementation is defined. - */ + /* operator== + lockPTRDatum should only use the equals method for equality testing. + Thus, the inherited lockPTR::operator== is made private. No + implementation is defined. + */ private: bool operator==( lockPTR< D >& ); }; From d33c6cd1c6aea4aefa8024f7787ea613f8760a0d Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 15:26:52 +0200 Subject: [PATCH 077/150] Update lockptrdatum.h --- sli/lockptrdatum.h | 8 -------- 1 file changed, 8 deletions(-) diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index 63378e749d..ff43a2d356 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -100,14 +100,6 @@ class lockPTRDatum : public lockPTR< D >, public TypedDatum< slt > // It is defined as identity of the underly D, i.e. &this->D == &other->D bool equals( const Datum* ) const; - /* operator= - The assignment operator is defaulted. - Therefore, lockPTR::operator= is called, and - TypedDatum::operator= is called. - The TypedDatum = is simply return *this. - */ - lockPTRDatum< D, sli >& operator=( const lockPTRDatum< D, sli >& ) - /* operator== lockPTRDatum should only use the equals method for equality testing. Thus, the inherited lockPTR::operator== is made private. No From 849f6d3e3a533f033fee48b65afd6d18ff91cae7 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 15:42:43 +0200 Subject: [PATCH 078/150] Update line numbers for known warnings --- build_support/parse_build_log.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/build_support/parse_build_log.py b/build_support/parse_build_log.py index 9ebc7e0d83..7e566ecb52 100755 --- a/build_support/parse_build_log.py +++ b/build_support/parse_build_log.py @@ -370,10 +370,10 @@ def makebuild_summary(log_filename, msg_make_section_start, nest_warning_re = re.compile(f'.*({build_dir}.*: warning:.*)') known_warnings = [ - f'{build_dir}/sli/scanner.cc:638:13: warning: this statement may fall through [-Wimplicit-fallthrough=]', - f'{build_dir}/sli/scanner.cc:668:19: warning: this statement may fall through [-Wimplicit-fallthrough=]', - f'{build_dir}/sli/scanner.cc:710:13: warning: this statement may fall through [-Wimplicit-fallthrough=]', - f'{build_dir}/sli/scanner.cc:738:24: warning: this statement may fall through [-Wimplicit-fallthrough=]', + f'{build_dir}/sli/scanner.cc:637:13: warning: this statement may fall through [-Wimplicit-fallthrough=]', + f'{build_dir}/sli/scanner.cc:667:19: warning: this statement may fall through [-Wimplicit-fallthrough=]', + f'{build_dir}/sli/scanner.cc:709:13: warning: this statement may fall through [-Wimplicit-fallthrough=]', + f'{build_dir}/sli/scanner.cc:737:24: warning: this statement may fall through [-Wimplicit-fallthrough=]', (f'{build_dir}/thirdparty/Random123/conventional/Engine.hpp:140:15: warning: implicitly-declared' ' ‘r123::Engine >& r123::Engine >::operator=' '(const r123::Engine >&)’ is deprecated [-Wdeprecated-copy]'), From 0851c3867a5e1c8edcfa0274c810e3a08b2d903f Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 16:04:29 +0200 Subject: [PATCH 079/150] Added std:: to signbit --- models/stdp_nn_symm_synapse.h | 2 +- models/urbanczik_synapse.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/models/stdp_nn_symm_synapse.h b/models/stdp_nn_symm_synapse.h index 1fdf644883..9e96e2e78a 100644 --- a/models/stdp_nn_symm_synapse.h +++ b/models/stdp_nn_symm_synapse.h @@ -331,7 +331,7 @@ stdp_nn_symm_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, updateValue< double >( d, names::Wmax, Wmax_ ); // check if weight_ and Wmax_ have the same sign - if ( signbit( weight_) != signbit( Wmax_) ) + if ( std::signbit( weight_) != std::signbit( Wmax_) ) { throw BadProperty( "Weight and Wmax must have same sign." ); } diff --git a/models/urbanczik_synapse.h b/models/urbanczik_synapse.h index 4313a035cb..dae22d3037 100644 --- a/models/urbanczik_synapse.h +++ b/models/urbanczik_synapse.h @@ -312,7 +312,7 @@ urbanczik_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Co init_weight_ = weight_; // check if weight_ and Wmin_ has the same sign - if ( signbit( weight_ ) != signbit( Wmax_ ) ) + if ( std::signbit( weight_ ) != std::signbit( Wmax_ ) ) { throw BadProperty( "Weight and Wmin must have same sign." ); } From 6b9cc2b05c0ec42c8273d16f853787475e222aab Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 16:54:12 +0200 Subject: [PATCH 080/150] Added back imports of pure implementation headers --- nestkernel/mpi_manager.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/nestkernel/mpi_manager.cpp b/nestkernel/mpi_manager.cpp index bb6747b65b..81cf2bdbd1 100644 --- a/nestkernel/mpi_manager.cpp +++ b/nestkernel/mpi_manager.cpp @@ -28,6 +28,7 @@ // Includes from nestkernel: #include "kernel_manager.h" +#include "mpi_manager_impl.h" #include "nest_types.h" // Includes from sli: From ee755ee3d1163166b98bb79dd2d5df39143d8bfb Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 18:25:41 +0200 Subject: [PATCH 081/150] Added back imports of pure implementation headers --- nestkernel/music_manager.cpp | 6 ++++++ nestkernel/nestmodule.cpp | 2 ++ nestkernel/node_manager.cpp | 1 + 3 files changed, 9 insertions(+) diff --git a/nestkernel/music_manager.cpp b/nestkernel/music_manager.cpp index 46c79ce0f0..f360bdec01 100644 --- a/nestkernel/music_manager.cpp +++ b/nestkernel/music_manager.cpp @@ -29,6 +29,12 @@ #endif #endif +// Includes from libnestutil: +#include "compose.hpp" + +// Includes from nestkernel: +#include "kernel_manager.h" + // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index 504e7bc10c..0195e9e960 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -30,6 +30,8 @@ // Includes from nestkernel: #include "conn_builder.h" +#include "conn_builder_conngen.h" +#include "connection_creator_impl.h" #include "connection_manager_impl.h" #include "genericmodel.h" #include "grid_layer.h" diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index b0ddbe0a33..9a9eaf112a 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -30,6 +30,7 @@ #include "logging.h" // Includes from nestkernel: +#include "event_delivery_manager.h" #include "kernel_manager.h" #include "model.h" #include "model_manager_impl.h" From 8147ee395bef0477de4c3311c157f02d9a60eb66 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 18:55:43 +0200 Subject: [PATCH 082/150] Applied clang-format v13 --- models/stdp_nn_symm_synapse.h | 2 +- sli/dictstack.cc | 6 +++--- sli/filesystem.cc | 4 ++-- sli/interpret.cc | 8 ++++---- sli/name.cc | 2 +- sli/oosupport.cc | 4 ++-- sli/parser.cc | 2 +- sli/processes.cc | 4 ++-- sli/specialfunctionsmodule.cc | 6 +++--- sli/tarrayobj.cc | 38 +++++++++++++++++------------------ sli/tokenarray.cc | 2 +- 11 files changed, 39 insertions(+), 39 deletions(-) diff --git a/models/stdp_nn_symm_synapse.h b/models/stdp_nn_symm_synapse.h index 9e96e2e78a..a63c005917 100644 --- a/models/stdp_nn_symm_synapse.h +++ b/models/stdp_nn_symm_synapse.h @@ -331,7 +331,7 @@ stdp_nn_symm_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, updateValue< double >( d, names::Wmax, Wmax_ ); // check if weight_ and Wmax_ have the same sign - if ( std::signbit( weight_) != std::signbit( Wmax_) ) + if ( std::signbit( weight_ ) != std::signbit( Wmax_ ) ) { throw BadProperty( "Weight and Wmax must have same sign." ); } diff --git a/sli/dictstack.cc b/sli/dictstack.cc index 012cf5eddb..b741aa4d2f 100644 --- a/sli/dictstack.cc +++ b/sli/dictstack.cc @@ -93,7 +93,7 @@ DictionaryStack::basedef_move( const Name& n, Token& t ) void -DictionaryStack::pop( ) +DictionaryStack::pop() { // // remove top dictionary from stack @@ -108,7 +108,7 @@ DictionaryStack::pop( ) } void -DictionaryStack::clear( ) +DictionaryStack::clear() { d.erase( d.begin(), d.end() ); #ifdef DICTSTACK_CACHE @@ -185,7 +185,7 @@ DictionaryStack::set_basedict() } size_t -DictionaryStack::size( ) const +DictionaryStack::size() const { // // return number of dictionaries on stack diff --git a/sli/filesystem.cc b/sli/filesystem.cc index b63426295b..d034cdf502 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -60,13 +60,13 @@ FilesystemModule::init( SLIInterpreter* i ) const std::string -FilesystemModule::name( ) const +FilesystemModule::name() const { return std::string( "Filesystem access" ); } const std::string -FilesystemModule::commandstring( ) const +FilesystemModule::commandstring() const { return std::string( "(filesystem.sli) run" ); } diff --git a/sli/interpret.cc b/sli/interpret.cc index 1413157948..85116bdd72 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -140,7 +140,7 @@ const IforallindexedstringFunction SLIInterpreter::iforallindexedstringfunction; const IforallstringFunction SLIInterpreter::iforallstringfunction; void -SLIInterpreter::inittypes( ) +SLIInterpreter::inittypes() { Integertype.settypename( "integertype" ); Integertype.setdefaultaction( datatypefunction ); @@ -183,7 +183,7 @@ SLIInterpreter::inittypes( ) } void -SLIInterpreter::initdictionaries( ) +SLIInterpreter::initdictionaries() { assert( DStack == nullptr ); @@ -204,7 +204,7 @@ SLIInterpreter::initdictionaries( ) } void -SLIInterpreter::initbuiltins( ) +SLIInterpreter::initbuiltins() { createcommand( ilookup_name, &SLIInterpreter::ilookupfunction ); @@ -224,7 +224,7 @@ SLIInterpreter::initbuiltins( ) } void -SLIInterpreter::initexternals( ) +SLIInterpreter::initexternals() { init_slidict( this ); init_slicontrol( this ); diff --git a/sli/name.cc b/sli/name.cc index a82b64ed06..4e2484b16c 100644 --- a/sli/name.cc +++ b/sli/name.cc @@ -69,7 +69,7 @@ Name::print_handle( std::ostream& o ) const const std::string& -Name::toString( ) const +Name::toString() const { return handleTableInstance_()[ handle_ ]; } diff --git a/sli/oosupport.cc b/sli/oosupport.cc index ff836e895e..79b17ce0d2 100644 --- a/sli/oosupport.cc +++ b/sli/oosupport.cc @@ -38,13 +38,13 @@ OOSupportModule::init( SLIInterpreter* i ) } const std::string -OOSupportModule::commandstring( ) const +OOSupportModule::commandstring() const { return std::string( "(oosupport.sli) run" ); } const std::string -OOSupportModule::name( ) const +OOSupportModule::name() const { return std::string( "OOSupport" ); } diff --git a/sli/parser.cc b/sli/parser.cc index f690d02c3a..2a46c9c767 100644 --- a/sli/parser.cc +++ b/sli/parser.cc @@ -63,7 +63,7 @@ Parser::Parser( std::istream& is ) assert( s != nullptr ); } -Parser::Parser( ) +Parser::Parser() : s( nullptr ) , ParseStack( 128 ) { diff --git a/sli/processes.cc b/sli/processes.cc index 82186d7c70..7a80351b81 100644 --- a/sli/processes.cc +++ b/sli/processes.cc @@ -148,13 +148,13 @@ Processes::fd( std::ostream* s ) // end of definition of static variables and functions const std::string -Processes::name( ) const +Processes::name() const { return std::string( "basic process management" ); // Return name of the module } const std::string -Processes::commandstring( ) const +Processes::commandstring() const { return std::string( "(processes.sli) run" ); } diff --git a/sli/specialfunctionsmodule.cc b/sli/specialfunctionsmodule.cc index e88e6dd2b2..6167ef2d7c 100644 --- a/sli/specialfunctionsmodule.cc +++ b/sli/specialfunctionsmodule.cc @@ -61,7 +61,7 @@ const SpecialFunctionsModule::LambertWm1Function lambertwm1function; // GSL independent code const std::string -SpecialFunctionsModule::name( ) const +SpecialFunctionsModule::name() const { return std::string( "SpecialFunctionsModule" ); // Return name of the module } @@ -275,7 +275,7 @@ SpecialFunctionsModule::ErfcFunction::execute( SLIInterpreter* i ) const gsl_function SpecialFunctionsModule::GaussDiskConvFunction::F_; -SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction( ) +SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction() { // allocate integration workspace w_ = gsl_integration_workspace_alloc( MAX_QUAD_SIZE ); @@ -284,7 +284,7 @@ SpecialFunctionsModule::GaussDiskConvFunction::GaussDiskConvFunction( ) F_.function = SpecialFunctionsModule::GaussDiskConvFunction::f_; } -SpecialFunctionsModule::GaussDiskConvFunction::~GaussDiskConvFunction( ) +SpecialFunctionsModule::GaussDiskConvFunction::~GaussDiskConvFunction() { // free integration workspace gsl_integration_workspace_free( w_ ); diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index a4c434045c..775df49526 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -211,7 +211,7 @@ TokenArrayObj::operator=( const TokenArrayObj& a ) // } bool -TokenArrayObj::shrink( ) +TokenArrayObj::shrink() { size_t new_capacity = size(); @@ -281,8 +281,8 @@ TokenArrayObj::erase( Token* first, Token* last ) // deleting NULL pointer is safe in ISO C++ to->p->removeReference(); } - to->p = from->p; // move - from->p = nullptr; // might be overwritten or not + to->p = from->p; // move + from->p = nullptr; // might be overwritten or not ++from; ++to; } @@ -317,7 +317,7 @@ TokenArrayObj::erase( size_t i, size_t n ) } void -TokenArrayObj::clear( ) +TokenArrayObj::clear() { if ( p ) { @@ -396,8 +396,8 @@ TokenArrayObj::insert( size_t i, size_t n, const Token& t ) while ( from >= pos ) { - to->p = from->p; // move - from->p = nullptr; // knowing that to->p is + to->p = from->p; // move + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } @@ -423,8 +423,8 @@ TokenArrayObj::insert_move( size_t i, TokenArrayObj& a ) while ( from >= pos ) { - to->p = from->p; // move - from->p = nullptr; // knowing that to->p is + to->p = from->p; // move + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } @@ -434,8 +434,8 @@ TokenArrayObj::insert_move( size_t i, TokenArrayObj& a ) while ( from < a.end() ) { - to->p = from->p; // we cannot do this in the loop - from->p = nullptr; // above because of overlapping + to->p = from->p; // we cannot do this in the loop + from->p = nullptr; // above because of overlapping ++from; ++to; } @@ -495,8 +495,8 @@ TokenArrayObj::insert_move( size_t i, Token& t ) while ( from >= pos ) { - to->p = from->p; // move - from->p = nullptr; // knowing that to->p is + to->p = from->p; // move + from->p = nullptr; // knowing that to->p is --from; --to; // NULL before } @@ -530,8 +530,8 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) while ( from > end ) { - to->p = from->p; // move - from->p = nullptr; // might be overwritten or not + to->p = from->p; // move + from->p = nullptr; // might be overwritten or not --from; --to; } @@ -552,8 +552,8 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) // deleting NULL pointer is safe in ISO C++ to->p->removeReference(); } - to->p = from->p; // move - from->p = nullptr; // might be overwritten or not + to->p = from->p; // move + from->p = nullptr; // might be overwritten or not ++from; ++to; } @@ -585,8 +585,8 @@ TokenArrayObj::replace_move( size_t i, size_t n, TokenArrayObj& a ) // delete target before to->p->removeReference(); } - to->p = from->p; // movement, it is typically - from->p = nullptr; // not the NULL pointer + to->p = from->p; // movement, it is typically + from->p = nullptr; // not the NULL pointer ++from; ++to; } @@ -660,7 +660,7 @@ TokenArrayObj::info( std::ostream& out ) const } bool -TokenArrayObj::valid( ) const +TokenArrayObj::valid() const { if ( p == nullptr ) { diff --git a/sli/tokenarray.cc b/sli/tokenarray.cc index 2c169a5989..3cd5b4a154 100644 --- a/sli/tokenarray.cc +++ b/sli/tokenarray.cc @@ -152,7 +152,7 @@ TokenArray::toVector( std::vector< std::string >& a ) const bool -TokenArray::valid( ) const +TokenArray::valid() const { if ( data == nullptr ) { From 8488b2c1471076cc8d5b9e614f6924f7dc621b85 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 19:41:26 +0200 Subject: [PATCH 083/150] Added back nestkernel includes as those are not necessarily static --- nestkernel/common_synapse_properties.cpp | 1 + nestkernel/conn_builder.cpp | 1 + nestkernel/conn_builder_conngen.cpp | 2 ++ nestkernel/conn_parameter.cpp | 1 + nestkernel/connection_manager.cpp | 3 +++ nestkernel/device.cpp | 4 ++++ nestkernel/dynamicloader.cpp | 1 + nestkernel/event.cpp | 1 + nestkernel/event_delivery_manager.cpp | 4 +++- nestkernel/io_manager.cpp | 4 ++++ nestkernel/music_manager.cpp | 10 ++++++++++ nestkernel/nest.cpp | 1 + nestkernel/nestmodule.cpp | 2 ++ nestkernel/node.cpp | 1 + nestkernel/node_manager.cpp | 1 + nestkernel/source_table.cpp | 1 + nestkernel/sp_manager.cpp | 1 + nestkernel/spatial.cpp | 1 + nestkernel/target_table_devices.cpp | 1 + 19 files changed, 40 insertions(+), 1 deletion(-) diff --git a/nestkernel/common_synapse_properties.cpp b/nestkernel/common_synapse_properties.cpp index 6ba06dd13c..69502b1d55 100644 --- a/nestkernel/common_synapse_properties.cpp +++ b/nestkernel/common_synapse_properties.cpp @@ -25,6 +25,7 @@ // Includes from nestkernel: #include "connector_model.h" #include "nest_timeconverter.h" +#include "nest_types.h" #include "node.h" // Includes from sli: diff --git a/nestkernel/conn_builder.cpp b/nestkernel/conn_builder.cpp index 147a599391..7e70c166bd 100644 --- a/nestkernel/conn_builder.cpp +++ b/nestkernel/conn_builder.cpp @@ -36,6 +36,7 @@ // Includes from sli: #include "dict.h" +#include "fdstream.h" #include "name.h" nest::ConnBuilder::ConnBuilder( NodeCollectionPTR sources, diff --git a/nestkernel/conn_builder_conngen.cpp b/nestkernel/conn_builder_conngen.cpp index 59ddef3cd0..d6f2f6119f 100644 --- a/nestkernel/conn_builder_conngen.cpp +++ b/nestkernel/conn_builder_conngen.cpp @@ -20,6 +20,8 @@ * */ +#include "conn_builder_conngen.h" + #ifdef HAVE_LIBNEUROSIM // Includes from nestkernel: diff --git a/nestkernel/conn_parameter.cpp b/nestkernel/conn_parameter.cpp index 6eb3d58b73..9cbcd24fd4 100644 --- a/nestkernel/conn_parameter.cpp +++ b/nestkernel/conn_parameter.cpp @@ -30,6 +30,7 @@ #include "arraydatum.h" #include "doubledatum.h" #include "integerdatum.h" +#include "tokenutils.h" nest::ConnParameter* nest::ConnParameter::create( const Token& t, const size_t nthreads ) diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index 1d6d45afdc..e605efff25 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -22,6 +22,9 @@ #include "connection_manager.h" +// Generated includes: +#include "config.h" + // C++ includes: #include #include diff --git a/nestkernel/device.cpp b/nestkernel/device.cpp index a142e66d73..d248e84e11 100644 --- a/nestkernel/device.cpp +++ b/nestkernel/device.cpp @@ -22,10 +22,14 @@ #include "device.h" +// C++ includes: +#include +#include // Includes from nestkernel: #include "exceptions.h" #include "nest_names.h" +#include "node.h" // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/dynamicloader.cpp b/nestkernel/dynamicloader.cpp index c411d4c9d4..009f9e2d3a 100644 --- a/nestkernel/dynamicloader.cpp +++ b/nestkernel/dynamicloader.cpp @@ -47,6 +47,7 @@ #include "model.h" // Includes from sli: +#include "integerdatum.h" #include "interpret.h" #include "stringdatum.h" diff --git a/nestkernel/event.cpp b/nestkernel/event.cpp index f43c959caa..109c094833 100644 --- a/nestkernel/event.cpp +++ b/nestkernel/event.cpp @@ -31,6 +31,7 @@ // Includes from nestkernel: #include "kernel_manager.h" +#include "node.h" namespace nest { diff --git a/nestkernel/event_delivery_manager.cpp b/nestkernel/event_delivery_manager.cpp index fe467c0571..2b99dbfbde 100644 --- a/nestkernel/event_delivery_manager.cpp +++ b/nestkernel/event_delivery_manager.cpp @@ -24,12 +24,14 @@ // C++ includes: #include // rotate -#include // accumulate +#include // accumulate // Includes from nestkernel: #include "connection_manager.h" #include "connection_manager_impl.h" +#include "event_delivery_manager_impl.h" #include "kernel_manager.h" +#include "mpi_manager_impl.h" #include "send_buffer_position.h" #include "source.h" #include "vp_manager.h" diff --git a/nestkernel/io_manager.cpp b/nestkernel/io_manager.cpp index 4c21d16b7b..714c1d3e40 100644 --- a/nestkernel/io_manager.cpp +++ b/nestkernel/io_manager.cpp @@ -22,9 +22,13 @@ #include "io_manager.h" +// Generated includes: +#include "config.h" + // C includes: #include #include +#include // C++ includes: #include diff --git a/nestkernel/music_manager.cpp b/nestkernel/music_manager.cpp index f360bdec01..0a874080f0 100644 --- a/nestkernel/music_manager.cpp +++ b/nestkernel/music_manager.cpp @@ -35,6 +35,16 @@ // Includes from nestkernel: #include "kernel_manager.h" +// C++ includes: +//#include + +// Includes from libnestutil: +#include "compose.hpp" +//#include "logging.h" + +// Includes from nestkernel: +#include "kernel_manager.h" + // Includes from sli: #include "dictutils.h" diff --git a/nestkernel/nest.cpp b/nestkernel/nest.cpp index 47af63b5eb..5fa567eee6 100644 --- a/nestkernel/nest.cpp +++ b/nestkernel/nest.cpp @@ -28,6 +28,7 @@ // Includes from nestkernel: #include "exceptions.h" #include "kernel_manager.h" +#include "mpi_manager_impl.h" #include "parameter.h" // Includes from sli: diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index 0195e9e960..25ba07fbb5 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -33,6 +33,7 @@ #include "conn_builder_conngen.h" #include "connection_creator_impl.h" #include "connection_manager_impl.h" +#include "free_layer.h" #include "genericmodel.h" #include "grid_layer.h" #include "grid_mask.h" @@ -41,6 +42,7 @@ #include "layer_impl.h" #include "mask.h" #include "mask_impl.h" +#include "model_manager_impl.h" #include "nest.h" #include "nest_datums.h" #include "nest_types.h" diff --git a/nestkernel/node.cpp b/nestkernel/node.cpp index 25725a7987..0a5c154638 100644 --- a/nestkernel/node.cpp +++ b/nestkernel/node.cpp @@ -31,6 +31,7 @@ #include "kernel_manager.h" // Includes from sli: +#include "arraydatum.h" #include "dictutils.h" #include "namedatum.h" diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index 9a9eaf112a..7ce920c466 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -31,6 +31,7 @@ // Includes from nestkernel: #include "event_delivery_manager.h" +#include "genericmodel.h" #include "kernel_manager.h" #include "model.h" #include "model_manager_impl.h" diff --git a/nestkernel/source_table.cpp b/nestkernel/source_table.cpp index dda02e4b16..ff1aba3846 100644 --- a/nestkernel/source_table.cpp +++ b/nestkernel/source_table.cpp @@ -24,6 +24,7 @@ #include // Includes from nestkernel: +#include "connection_manager.h" #include "connection_manager_impl.h" #include "kernel_manager.h" #include "mpi_manager_impl.h" diff --git a/nestkernel/sp_manager.cpp b/nestkernel/sp_manager.cpp index 50f4667695..1c4b0497f8 100644 --- a/nestkernel/sp_manager.cpp +++ b/nestkernel/sp_manager.cpp @@ -34,6 +34,7 @@ // Includes from nestkernel: #include "conn_builder.h" +#include "conn_parameter.h" #include "connector_base.h" #include "connector_model.h" #include "kernel_manager.h" diff --git a/nestkernel/spatial.cpp b/nestkernel/spatial.cpp index 57a9fabc92..20edc85161 100644 --- a/nestkernel/spatial.cpp +++ b/nestkernel/spatial.cpp @@ -23,6 +23,7 @@ #include "spatial.h" // C++ includes: +#include #include // Includes from libnestutil: diff --git a/nestkernel/target_table_devices.cpp b/nestkernel/target_table_devices.cpp index 1f6f2ad23f..5035ce8380 100644 --- a/nestkernel/target_table_devices.cpp +++ b/nestkernel/target_table_devices.cpp @@ -23,6 +23,7 @@ // Includes from nestkernel: #include "connector_base.h" #include "kernel_manager.h" +#include "target_table_devices_impl.h" #include "vp_manager_impl.h" nest::TargetTableDevices::TargetTableDevices() From 3ac2db4e3835a3d8a5fd901f96ea4dd0fe1b80b4 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 19:57:39 +0200 Subject: [PATCH 084/150] Update dictutils.h --- sli/dictutils.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sli/dictutils.h b/sli/dictutils.h index bc355b5556..46a5be969d 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -27,6 +27,7 @@ #include #include #include +#include // Includes from sli: #include "arraydatum.h" @@ -90,7 +91,7 @@ get_double_in_range( const DictionaryDatum& d, Name const n, double min, double // token. const Token& t = d->lookup2( n ); DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); - double x; + double x = std::numeric_limits< double >::quiet_NaN(); if ( dd != 0 ) { From 7443ad4f6b39fd02216b4c8bd8d202ef8d8c3d35 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Tue, 4 Oct 2022 19:58:31 +0200 Subject: [PATCH 085/150] Update dictutils.h --- sli/dictutils.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/dictutils.h b/sli/dictutils.h index 46a5be969d..5f826ee680 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -155,7 +155,7 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i // token. const Token& t = d->lookup2( n ); DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); - long x; + long x = std::numeric_limits< long >::quiet_NaN(); if ( dd != 0 ) { From 088b262018b79671e917f13f9ae9f3a7cb164fed Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 20:00:34 +0200 Subject: [PATCH 086/150] Applied clang-format v13 --- nestkernel/event_delivery_manager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/event_delivery_manager.cpp b/nestkernel/event_delivery_manager.cpp index 2b99dbfbde..41bee3106c 100644 --- a/nestkernel/event_delivery_manager.cpp +++ b/nestkernel/event_delivery_manager.cpp @@ -24,7 +24,7 @@ // C++ includes: #include // rotate -#include // accumulate +#include // accumulate // Includes from nestkernel: #include "connection_manager.h" From 34240e955a76756ecc9d1f9a6344ab2cded66038 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 4 Oct 2022 23:11:29 +0200 Subject: [PATCH 087/150] Applied clang-format v13 --- sli/dictutils.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/dictutils.h b/sli/dictutils.h index 5f826ee680..973a28880c 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -26,8 +26,8 @@ // C++ includes: #include #include -#include #include +#include // Includes from sli: #include "arraydatum.h" From a8b8ca151b6842b15679568bee34d319d7cdc1c3 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Thu, 6 Oct 2022 12:32:46 +0200 Subject: [PATCH 088/150] Converted test to modern pytest --- testsuite/pytests/test_copy_model.py | 152 ++++++++++++++++----------- 1 file changed, 93 insertions(+), 59 deletions(-) diff --git a/testsuite/pytests/test_copy_model.py b/testsuite/pytests/test_copy_model.py index eb5406628a..15d6306c3a 100644 --- a/testsuite/pytests/test_copy_model.py +++ b/testsuite/pytests/test_copy_model.py @@ -24,68 +24,102 @@ and new Ids are correctly assigned to the new copied models. """ -import unittest import nest +import pytest @nest.ll_api.check_stack -class CopyModelTestCase(unittest.TestCase): +class TestCopyModel: """nest.CopyModel Test""" - def test_builtin_models(self): - """Check the correctness of the nest.CopyModel on all built-in models""" - - for model in nest.node_models + nest.synapse_models: - self.check_copied_model_ids(model) - - def check_copied_model_ids(self, original_model): - """Test if copied models get correct model IDs""" - - model_type = nest.GetDefaults(original_model, "element_type") - - model_name_key = "model" - model_id_key = "model_id" - if model_type == "synapse": - model_name_key = "synapse_model" - model_id_key = "synapse_modelid" - - original_model_id = nest.GetDefaults(original_model)[model_id_key] - - new_name = f"{original_model}_copy" - nest.CopyModel(original_model, new_name) - copied_model_id = nest.GetDefaults(new_name)[model_id_key] - - self.assertGreater(copied_model_id, original_model_id) - - if model_type == "neuron": - original_model_instance = nest.Create(original_model) - copied_model_instance = nest.Create(new_name) - - original_model_name = original_model_instance.get(model_name_key) - copied_model_name = copied_model_instance.get(model_name_key) - self.assertNotEqual(original_model_name, copied_model_name) - self.assertNotEqual(copied_model_name, "UnknownNode") - - original_model_id = original_model_instance.get(model_id_key) - copied_model_id = copied_model_instance.get(model_id_key) - self.assertGreater(copied_model_id, original_model_id) - - def test_CopyModel(self): - """Test CopyModel""" - - nest.CopyModel('iaf_psc_alpha', 'new_neuron', {'V_m': 10.0}) - vm = nest.GetDefaults('new_neuron')['V_m'] - self.assertEqual(vm, 10.0) - - n = nest.Create('new_neuron', 10) - vm = nest.GetStatus(n[0])[0]['V_m'] - self.assertEqual(vm, 10.0) - - nest.CopyModel('static_synapse', 'new_synapse', {'weight': 10.}) - nest.Connect(n[0], n[1], syn_spec='new_synapse') - w = nest.GetDefaults('new_synapse')['weight'] - self.assertEqual(w, 10.0) - - self.assertRaisesRegex( - nest.kernel.NESTError, "NewModelNameExists", - nest.CopyModel, 'iaf_psc_alpha', 'new_neuron') + @pytest.fixture(autouse=True) + def reset_kernel(self): + """ + Reset kernel to clear copied models. + """ + + nest.ResetKernel() + + @pytest.mark.parametrize('org_model', nest.node_models) + def test_copy_node_models(self, org_model): + """ + Test that all built-in node models can be copied. + + Nodes created from copy must have higher model_id and correct name. + """ + + new_model = f"{org_model}_copy" + nest.CopyModel(org_model, new_model) + + org_node = nest.Create(org_model) + new_node = nest.Create(new_model) + + assert new_node.model_id > org_node.model_id + assert new_node.model == new_model + + @pytest.mark.parametrize('org_model', nest.synapse_models) + def test_copy_synapse_models(self, org_model): + """ + Test that all built-in synapse models can be copied. + + Name and id only checked on model and not on actual synapse + because some synapse models only work for some neuron models. + """ + + new_model = f"{org_model}_copy" + nest.CopyModel(org_model, new_model) + + assert (nest.GetDefaults(new_model)['synapse_modelid'] + > nest.GetDefaults(org_model)['synapse_modelid']) + assert nest.GetDefaults(new_model)['synapse_model'] == new_model + + def test_set_param_on_copy_neuron(self): + """ + Test that parameter is correctly set when neuron model is copied. + """ + + test_params = {'V_m': 10.0, 'tau_m': 100.0} + nest.CopyModel('iaf_psc_alpha', 'new_neuron', test_params) + n = nest.Create('new_neuron') + for k, v in test_params.items(): + assert n.get(k) == pytest.approx(v) + + def test_set_param_on_copy_synapse(self): + """ + Test that parameter is correctly set when neuron model is copied. + """ + + test_params = {'weight': 10.0, 'delay': 2.0, 'alpha': 99.0} + nest.CopyModel('stdp_synapse', 'new_synapse', test_params) + n = nest.Create('iaf_psc_alpha') + nest.Connect(n, n, syn_spec='new_synapse') + conn = nest.GetConnections() + for k, v in test_params.items(): + assert conn.get(k) == pytest.approx(v) + + @pytest.mark.parametrize('org_model', [nest.node_models[0], + nest.synapse_models[0]]) + def test_cannot_copy_to_existing_model(self, org_model): + """ + Test that we cannot copy to an existing model. + """ + + try: + org_name = nest.GetDefaults(org_model)['model'] + except KeyError: + org_name = nest.GetDefaults(org_model)['synapse_model'] + + with pytest.raises(nest.kernel.NESTError, match='NewModelNameExists'): + nest.CopyModel(org_model, org_model) + + @pytest.mark.parametrize('org_model', [nest.node_models[0], + nest.synapse_models[0]]) + def test_cannot_copy_twice(self, org_model): + """ + Test that we cannot copy twice to the same name. + """ + + new_model = f"{org_model}_copy" + nest.CopyModel(org_model, new_model) + with pytest.raises(nest.kernel.NESTError, match='NewModelNameExists'): + nest.CopyModel(org_model, new_model) From 7696763104c2e7d29d8f8ce9007cb6b5a412d736 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Thu, 6 Oct 2022 14:41:47 +0200 Subject: [PATCH 089/150] Turn off 'fail on error' while running py/cpp tests to ensure log analysis can run at end. --- testsuite/do_tests.sh | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/testsuite/do_tests.sh b/testsuite/do_tests.sh index c20804acdc..2903bd22a7 100755 --- a/testsuite/do_tests.sh +++ b/testsuite/do_tests.sh @@ -494,16 +494,20 @@ if test "${PYTHON}"; then # Run all tests except those in the mpi* subdirectories because they cannot be run concurrently XUNIT_FILE="${REPORTDIR}/${XUNIT_NAME}.xml" + set +e "${PYTHON}" -m pytest --verbose --timeout $TIME_LIMIT --junit-xml="${XUNIT_FILE}" --numprocesses=1 \ --ignore="${PYNEST_TEST_DIR}/mpi" "${PYNEST_TEST_DIR}" 2>&1 | tee -a "${TEST_LOGFILE}" - + set -e + # Run tests in the mpi* subdirectories, grouped by number of processes if test "${HAVE_MPI}" = "true"; then if test "${MPI_LAUNCHER}"; then for numproc in $(cd ${PYNEST_TEST_DIR}/mpi/; ls -d */ | tr -d '/'); do XUNIT_FILE="${REPORTDIR}/${XUNIT_NAME}_mpi_${numproc}.xml" PYTEST_ARGS="--verbose --timeout $TIME_LIMIT --junit-xml=${XUNIT_FILE} ${PYNEST_TEST_DIR}/mpi/${numproc}" + set +e $(sli -c "${numproc} (${PYTHON} -m pytest) (${PYTEST_ARGS}) mpirun =only") 2>&1 | tee -a "${TEST_LOGFILE}" + set -e done fi fi @@ -518,7 +522,9 @@ echo "Phase 8: Running C++ tests (experimental)" echo "-----------------------------------------" if command -v run_all_cpptests >/dev/null 2>&1; then + set +e CPP_TEST_OUTPUT=$( run_all_cpptests --logger=JUNIT,error,"${REPORTDIR}/08_cpptests.xml":HRF,error,stdout 2>&1 ) + set -e echo "${CPP_TEST_OUTPUT}" | tail -2 else echo " Not running C++ tests because NEST was compiled without Boost." From 747aae36824298d7428ad64e7dc87ec4ea7aa5d9 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Thu, 6 Oct 2022 17:03:10 +0200 Subject: [PATCH 090/150] Improved doc text in response to reviewer input --- models/noise_generator.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index 4dd56ba7d4..d6b62fce59 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -87,11 +87,11 @@ changes must be a multiple of the time step. .. admonition:: Recording the generated current - You can use a :doc:`multimeter ` to record the average current sent to all targets for each time step, provided you - are simulating using a single thread (multiple MPI processes with one thread each also work). In this case, - the recording interval of the should be the simulation resolution to avoid confusing effects + You can use a :doc:`multimeter ` to record the average current sent to all targets for each time step + if simulating on a single thread; multiple MPI processes with one thread each also work. In this case, + the recording interval of the multimeter should be the equal to the simulation resolution to avoid confusing effects due to offset or drift between the recording times of the multimeter and the switching times of the - noise generator. In multi-threaded mode, recording is prohibited for technical reasons. + noise generator. In multi-threaded mode, recording is noise current is prohibited for technical reasons. .. include:: ../models/stimulation_device.rst From 8c0f458971d8b04cf747ac8c40f1c19b250c65f3 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Thu, 6 Oct 2022 17:06:04 +0200 Subject: [PATCH 091/150] Fixed spurious PEP8 errors --- pynest/examples/spatial/conncon_sources.py | 3 ++- testsuite/pytests/test_spatial_positions.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/pynest/examples/spatial/conncon_sources.py b/pynest/examples/spatial/conncon_sources.py index 04f026284f..0c8e2f3b9c 100644 --- a/pynest/examples/spatial/conncon_sources.py +++ b/pynest/examples/spatial/conncon_sources.py @@ -25,7 +25,8 @@ Create two populations of iaf_psc_alpha neurons on a 30x30 grid -Connect the two populations with convergent projection and rectangular mask, and isualize connection from target perspective. +Connect the two populations with convergent projection and rectangular mask +and visualize connection from target perspective. BCCN Tutorial @ CNS*09 Hans Ekkehard Plesser, UMB diff --git a/testsuite/pytests/test_spatial_positions.py b/testsuite/pytests/test_spatial_positions.py index 3f2927a0a3..9602fbb8bc 100644 --- a/testsuite/pytests/test_spatial_positions.py +++ b/testsuite/pytests/test_spatial_positions.py @@ -48,7 +48,7 @@ def testFreePositions(reset): # The expected weight is the distance, which corresponds to the position on the x-axis, # which corresponds to the node ID. expected_weight = [0.1 * t for t in conns.target] - assert(conns.weight == expected_weight) + assert conns.weight == expected_weight def testGridPositions(reset): @@ -62,4 +62,4 @@ def testGridPositions(reset): # The expected weight is the distance, which corresponds to the position on the x-axis, # which corresponds to the node ID. expected_weight = conns.target - assert(conns.weight == expected_weight) + assert conns.weight == expected_weight From 7947a82ba0cd35aff959f2653da7e875c73fbaec Mon Sep 17 00:00:00 2001 From: Jan Vogelsang <47158055+JanVogelsang@users.noreply.github.com> Date: Thu, 6 Oct 2022 20:55:52 +0200 Subject: [PATCH 092/150] Update music_manager.cpp --- nestkernel/music_manager.cpp | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/nestkernel/music_manager.cpp b/nestkernel/music_manager.cpp index 0a874080f0..3e89c1e548 100644 --- a/nestkernel/music_manager.cpp +++ b/nestkernel/music_manager.cpp @@ -29,19 +29,6 @@ #endif #endif -// Includes from libnestutil: -#include "compose.hpp" - -// Includes from nestkernel: -#include "kernel_manager.h" - -// C++ includes: -//#include - -// Includes from libnestutil: -#include "compose.hpp" -//#include "logging.h" - // Includes from nestkernel: #include "kernel_manager.h" From 0c632a82be75f5b6b38c955570fc16cbe207596e Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 6 Oct 2022 20:59:33 +0200 Subject: [PATCH 093/150] Applied corrections --- libnestutil/beta_normalization_factor.h | 6 ++---- models/iaf_cond_beta.h | 26 ++++++++++++------------- models/iaf_psc_exp_multisynapse.cpp | 2 +- models/stdp_synapse_facetshw_hom.h | 2 +- nestkernel/proxynode.h | 1 - sli/dictstack.h | 2 -- 6 files changed, 17 insertions(+), 22 deletions(-) diff --git a/libnestutil/beta_normalization_factor.h b/libnestutil/beta_normalization_factor.h index c722f38657..09f7569918 100644 --- a/libnestutil/beta_normalization_factor.h +++ b/libnestutil/beta_normalization_factor.h @@ -75,7 +75,6 @@ beta_normalization_factor( const double tau_rise, const double tau_decay ) { const double tau_difference = tau_decay - tau_rise; double peak_value = 0; - double normalization_factor; if ( std::abs( tau_difference ) > std::numeric_limits< double >::epsilon() ) { // peak time @@ -86,14 +85,13 @@ beta_normalization_factor( const double tau_rise, const double tau_decay ) if ( std::abs( peak_value ) < std::numeric_limits< double >::epsilon() ) { // if rise time == decay time use alpha function - normalization_factor = 1. * numerics::e / tau_decay; + return numerics::e / tau_decay; } else { // if rise time != decay time use beta function - normalization_factor = ( 1. / tau_rise - 1. / tau_decay ) / peak_value; + return ( 1. / tau_rise - 1. / tau_decay ) / peak_value; } - return normalization_factor; } } // of namespace nest diff --git a/models/iaf_cond_beta.h b/models/iaf_cond_beta.h index 4ac4e15251..7e9dca037c 100644 --- a/models/iaf_cond_beta.h +++ b/models/iaf_cond_beta.h @@ -156,7 +156,7 @@ class iaf_cond_beta : public ArchivingNode public: iaf_cond_beta(); iaf_cond_beta( const iaf_cond_beta& ); - ~iaf_cond_beta(); + ~iaf_cond_beta() override; /* * Import all overloaded virtual functions that we @@ -167,24 +167,24 @@ class iaf_cond_beta : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node& tagret, rport receptor_type, synindex, bool ); + port send_test_event( Node& tagret, rport receptor_type, synindex, bool ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); + void init_buffers_() override; double get_normalisation_factor( double, double ); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/iaf_psc_exp_multisynapse.cpp b/models/iaf_psc_exp_multisynapse.cpp index e6bcc6abc3..5fc12fee74 100644 --- a/models/iaf_psc_exp_multisynapse.cpp +++ b/models/iaf_psc_exp_multisynapse.cpp @@ -175,7 +175,7 @@ iaf_psc_exp_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* node const size_t old_n_receptors = this->n_receptors_(); if ( updateValue< std::vector< double > >( d, "tau_syn", tau_syn_ ) ) { - if ( this->n_receptors_() != old_n_receptors && has_connections_ ) + if ( this->n_receptors_() != old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be reduced." ); } diff --git a/models/stdp_synapse_facetshw_hom.h b/models/stdp_synapse_facetshw_hom.h index e312be80a8..674af88b43 100644 --- a/models/stdp_synapse_facetshw_hom.h +++ b/models/stdp_synapse_facetshw_hom.h @@ -412,7 +412,7 @@ stdp_facetshw_synapse_hom< targetidentifierT >::send( Event& e, const_cast< STDPFACETSHWHomCommonProperties< targetidentifierT >& >( cp ); // init the readout time - if ( !init_flag_ ) + if ( not init_flag_ ) { synapse_id_ = cp.no_synapses_; ++cp_nonconst.no_synapses_; diff --git a/nestkernel/proxynode.h b/nestkernel/proxynode.h index 4172aad5e7..4f68e5adc0 100644 --- a/nestkernel/proxynode.h +++ b/nestkernel/proxynode.h @@ -115,7 +115,6 @@ class proxynode : public Node get_thread() { assert( false ); - return invalid_thread; } private: diff --git a/sli/dictstack.h b/sli/dictstack.h index 56977e70ee..84639d3ab9 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -66,8 +66,6 @@ #define DICTSTACK_CACHE 1 #endif -// #undef DICTSTACK_CACHE - class DictionaryStack { private: From ed2c609e6ee39d9507a2ff60956a25110a05e3ec Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 11:26:05 +0200 Subject: [PATCH 094/150] Changed static to const in proxynode::get_thread() and changed NaN to min in dictutils --- nestkernel/proxynode.h | 4 ++-- sli/dictutils.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/nestkernel/proxynode.h b/nestkernel/proxynode.h index 4f68e5adc0..915499eb68 100644 --- a/nestkernel/proxynode.h +++ b/nestkernel/proxynode.h @@ -111,8 +111,8 @@ class proxynode : public Node bool is_proxy() const override; - static thread - get_thread() + thread + get_thread() const { assert( false ); } diff --git a/sli/dictutils.h b/sli/dictutils.h index 973a28880c..51f0edb2f2 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -155,7 +155,7 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i // token. const Token& t = d->lookup2( n ); DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); - long x = std::numeric_limits< long >::quiet_NaN(); + long x = std::numeric_limits< long >::min(); if ( dd != 0 ) { From 83853d087e8496a0b7e75361092c1e247465ca5c Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 7 Oct 2022 11:40:44 +0200 Subject: [PATCH 095/150] Limit synapse copying test to first 66 models until #2492 is fixed --- testsuite/pytests/test_copy_model.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testsuite/pytests/test_copy_model.py b/testsuite/pytests/test_copy_model.py index 15d6306c3a..af7324fffc 100644 --- a/testsuite/pytests/test_copy_model.py +++ b/testsuite/pytests/test_copy_model.py @@ -57,7 +57,8 @@ def test_copy_node_models(self, org_model): assert new_node.model_id > org_node.model_id assert new_node.model == new_model - @pytest.mark.parametrize('org_model', nest.synapse_models) + # Limit to first 66 models until #2492 is fixed + @pytest.mark.parametrize('org_model', nest.synapse_models[:66]) def test_copy_synapse_models(self, org_model): """ Test that all built-in synapse models can be copied. From ebcff33a08e02b8db96e851c9b7c3a2fb2c0bc41 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 7 Oct 2022 11:55:22 +0200 Subject: [PATCH 096/150] Fix typos. Co-authored-by: Jochen Martin Eppler --- models/noise_generator.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index d6b62fce59..5c8bc58214 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -91,7 +91,7 @@ changes must be a multiple of the time step. if simulating on a single thread; multiple MPI processes with one thread each also work. In this case, the recording interval of the multimeter should be the equal to the simulation resolution to avoid confusing effects due to offset or drift between the recording times of the multimeter and the switching times of the - noise generator. In multi-threaded mode, recording is noise current is prohibited for technical reasons. + noise generator. In multi-threaded mode, recording of noise currents is prohibited for technical reasons. .. include:: ../models/stimulation_device.rst From f6535a21b75f398bf4c3000bb902986fca4a03b6 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 7 Oct 2022 12:08:09 +0200 Subject: [PATCH 097/150] Removed empty line not liked by Vera++ --- models/noise_generator.h | 1 - 1 file changed, 1 deletion(-) diff --git a/models/noise_generator.h b/models/noise_generator.h index 5c8bc58214..4215c3acb4 100644 --- a/models/noise_generator.h +++ b/models/noise_generator.h @@ -115,7 +115,6 @@ phase The phase of sine modulation (0–360 deg) - Setting parameters from a stimulation backend ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From 3cc208044812c6b799853f8d8eac365e4bbac48a Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 11:38:18 +0200 Subject: [PATCH 098/150] Use nullptr instead of NULL or 0 --- models/aeif_psc_delta.cpp | 20 +- models/aeif_psc_exp.cpp | 20 +- models/gif_cond_exp_multisynapse.cpp | 20 +- models/hh_cond_exp_traub.cpp | 20 +- models/iaf_cond_exp_sfa_rr.cpp | 20 +- models/pp_cond_exp_mc_urbanczik.cpp | 20 +- models/stdp_dopamine_synapse.cpp | 8 +- nestkernel/conn_builder.cpp | 4 +- nestkernel/connection_manager.cpp | 28 +-- nestkernel/kernel_manager.cpp | 4 +- nestkernel/layer_impl.h | 4 +- nestkernel/model_manager.cpp | 6 +- sli/aggregatedatum.h | 2 +- sli/dictstack.h | 10 +- sli/dictutils.h | 14 +- sli/functiondatum.h | 4 +- sli/gnureadline.cc | 6 +- sli/interpret.cc | 34 ++-- sli/sliarray.cc | 274 +++++++++++++-------------- sli/slidata.cc | 122 ++++++------ sli/slidict.cc | 42 ++-- sli/sligraphics.cc | 6 +- sli/slimath.cc | 36 ++-- sli/sliregexp.cc | 18 +- sli/slistack.cc | 14 +- sli/slistartup.cc | 4 +- sli/slitype.cc | 2 +- sli/slitype.h | 4 +- sli/slitypecheck.cc | 20 +- sli/tarrayobj.h | 6 +- 30 files changed, 396 insertions(+), 396 deletions(-) diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 8d5e94c812..688f673096 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -278,9 +278,9 @@ nest::aeif_psc_delta::State_::set( const DictionaryDatum& d, const Parameters_&, nest::aeif_psc_delta::Buffers_::Buffers_( aeif_psc_delta& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -288,9 +288,9 @@ nest::aeif_psc_delta::Buffers_::Buffers_( aeif_psc_delta& n ) nest::aeif_psc_delta::Buffers_::Buffers_( const Buffers_&, aeif_psc_delta& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -352,7 +352,7 @@ nest::aeif_psc_delta::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -360,7 +360,7 @@ nest::aeif_psc_delta::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -369,7 +369,7 @@ nest::aeif_psc_delta::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -378,7 +378,7 @@ nest::aeif_psc_delta::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_psc_delta_dynamics; diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 04112300f1..8f909199f2 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -295,9 +295,9 @@ nest::aeif_psc_exp::State_::set( const DictionaryDatum& d, const Parameters_&, N nest::aeif_psc_exp::Buffers_::Buffers_( aeif_psc_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -305,9 +305,9 @@ nest::aeif_psc_exp::Buffers_::Buffers_( aeif_psc_exp& n ) nest::aeif_psc_exp::Buffers_::Buffers_( const Buffers_&, aeif_psc_exp& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -370,7 +370,7 @@ nest::aeif_psc_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -379,7 +379,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -388,7 +388,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -397,7 +397,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_evolve_reset( B_.e_ ); } - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_psc_exp_dynamics; diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index c1966d08ee..55e2a0a250 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -330,9 +330,9 @@ nest::gif_cond_exp_multisynapse::State_::set( const DictionaryDatum& d, const Pa nest::gif_cond_exp_multisynapse::Buffers_::Buffers_( gif_cond_exp_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( Time::get_resolution().get_ms() ) , IntegrationStep_( step_ ) { @@ -342,9 +342,9 @@ nest::gif_cond_exp_multisynapse::Buffers_::Buffers_( gif_cond_exp_multisynapse& nest::gif_cond_exp_multisynapse::Buffers_::Buffers_( const Buffers_& b, gif_cond_exp_multisynapse& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) , step_( b.step_ ) , IntegrationStep_( b.IntegrationStep_ ) { @@ -412,7 +412,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, state_size ); } @@ -421,7 +421,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -430,7 +430,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( state_size ); } @@ -440,7 +440,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() } B_.sys_.function = gif_cond_exp_multisynapse_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = state_size; B_.sys_.params = reinterpret_cast< void* >( this ); } diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index 87f32e10f6..be50074528 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -265,9 +265,9 @@ nest::hh_cond_exp_traub::State_::set( const DictionaryDatum& d, const Parameters nest::hh_cond_exp_traub::Buffers_::Buffers_( hh_cond_exp_traub& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -275,9 +275,9 @@ nest::hh_cond_exp_traub::Buffers_::Buffers_( hh_cond_exp_traub& n ) nest::hh_cond_exp_traub::Buffers_::Buffers_( const Buffers_&, hh_cond_exp_traub& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -340,7 +340,7 @@ nest::hh_cond_exp_traub::init_buffers_() B_.I_stim_ = 0.0; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -349,7 +349,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -358,7 +358,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -368,7 +368,7 @@ nest::hh_cond_exp_traub::init_buffers_() } B_.sys_.function = hh_cond_exp_traub_dynamics; - B_.sys_.jacobian = 0; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); } diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index b38ac19c1c..15987a3b0d 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -259,9 +259,9 @@ nest::iaf_cond_exp_sfa_rr::State_::set( const DictionaryDatum& d, const Paramete nest::iaf_cond_exp_sfa_rr::Buffers_::Buffers_( iaf_cond_exp_sfa_rr& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -269,9 +269,9 @@ nest::iaf_cond_exp_sfa_rr::Buffers_::Buffers_( iaf_cond_exp_sfa_rr& n ) nest::iaf_cond_exp_sfa_rr::Buffers_::Buffers_( const Buffers_&, iaf_cond_exp_sfa_rr& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -332,7 +332,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -341,7 +341,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -350,7 +350,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -360,7 +360,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() } B_.sys_.function = iaf_cond_exp_sfa_rr_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index b3d81a4bdc..d9dc40a875 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -305,9 +305,9 @@ nest::pp_cond_exp_mc_urbanczik::State_::operator=( const State_& s ) nest::pp_cond_exp_mc_urbanczik::Buffers_::Buffers_( pp_cond_exp_mc_urbanczik& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -315,9 +315,9 @@ nest::pp_cond_exp_mc_urbanczik::Buffers_::Buffers_( pp_cond_exp_mc_urbanczik& n nest::pp_cond_exp_mc_urbanczik::Buffers_::Buffers_( const Buffers_&, pp_cond_exp_mc_urbanczik& n ) : logger_( n ) - , s_( 0 ) - , c_( 0 ) - , e_( 0 ) + , s_( nullptr ) + , c_( nullptr ) + , e_( nullptr ) { // Initialization of the remaining members is deferred to // init_buffers_(). @@ -516,7 +516,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == 0 ) + if ( B_.s_ == nullptr ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -525,7 +525,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == 0 ) + if ( B_.c_ == nullptr ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -534,7 +534,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == 0 ) + if ( B_.e_ == nullptr ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } @@ -544,7 +544,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() } B_.sys_.function = pp_cond_exp_mc_urbanczik_dynamics; - B_.sys_.jacobian = NULL; + B_.sys_.jacobian = nullptr; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); for ( size_t n = 0; n < NCOMP; ++n ) diff --git a/models/stdp_dopamine_synapse.cpp b/models/stdp_dopamine_synapse.cpp index 161c3b62b6..432d84a1b6 100644 --- a/models/stdp_dopamine_synapse.cpp +++ b/models/stdp_dopamine_synapse.cpp @@ -39,7 +39,7 @@ namespace nest STDPDopaCommonProperties::STDPDopaCommonProperties() : CommonSynapseProperties() - , vt_( 0 ) + , vt_( nullptr ) , A_plus_( 1.0 ) , A_minus_( 1.5 ) , tau_plus_( 20.0 ) @@ -55,7 +55,7 @@ void STDPDopaCommonProperties::get_status( DictionaryDatum& d ) const { CommonSynapseProperties::get_status( d ); - if ( vt_ != 0 ) + if ( vt_ != nullptr ) { def< long >( d, names::vt, vt_->get_node_id() ); } @@ -85,7 +85,7 @@ STDPDopaCommonProperties::set_status( const DictionaryDatum& d, ConnectorModel& const thread tid = kernel().vp_manager.get_thread_id(); Node* vt = kernel().node_manager.get_node_or_proxy( vtnode_id, tid ); vt_ = dynamic_cast< volume_transmitter* >( vt ); - if ( vt_ == 0 ) + if ( vt_ == nullptr ) { throw BadProperty( "Dopamine source must be volume transmitter" ); } @@ -104,7 +104,7 @@ STDPDopaCommonProperties::set_status( const DictionaryDatum& d, ConnectorModel& Node* STDPDopaCommonProperties::get_node() { - if ( vt_ == 0 ) + if ( vt_ == nullptr ) { throw BadProperty( "No volume transmitter has been assigned to the dopamine synapse." ); } diff --git a/nestkernel/conn_builder.cpp b/nestkernel/conn_builder.cpp index 7e70c166bd..1e82c147fb 100644 --- a/nestkernel/conn_builder.cpp +++ b/nestkernel/conn_builder.cpp @@ -1755,14 +1755,14 @@ nest::SymmetricBernoulliBuilder::connect_() // if target is local: connect if ( target_thread == tid ) { - assert( target != NULL ); + assert( target != nullptr ); single_connect_( snode_id, *target, target_thread, synced_rng ); } // if source is local: connect if ( source_thread == tid ) { - assert( source != NULL ); + assert( source != nullptr ); single_connect_( ( *tnode_id ).node_id, *source, source_thread, synced_rng ); } diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index e605efff25..e43b50b8a1 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -233,9 +233,9 @@ nest::ConnectionManager::get_synapse_status( const index source_node_id, // synapses from neurons to neurons and from neurons to globally // receiving devices - if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != NULL ) + if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != nullptr ) or ( ( source->has_proxies() and not target->has_proxies() and not target->local_receiver() - and connections_[ tid ][ syn_id ] != NULL ) ) ) + and connections_[ tid ][ syn_id ] != nullptr ) ) ) { connections_[ tid ][ syn_id ]->get_synapse_status( tid, lcid, dict ); } @@ -274,9 +274,9 @@ nest::ConnectionManager::set_synapse_status( const index source_node_id, ConnectorModel& cm = kernel().model_manager.get_connection_model( syn_id, tid ); // synapses from neurons to neurons and from neurons to globally // receiving devices - if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != NULL ) + if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != nullptr ) or ( ( source->has_proxies() and not target->has_proxies() and not target->local_receiver() - and connections_[ tid ][ syn_id ] != NULL ) ) ) + and connections_[ tid ][ syn_id ] != nullptr ) ) ) { connections_[ tid ][ syn_id ]->set_synapse_status( lcid, dict, cm ); } @@ -416,7 +416,7 @@ nest::ConnectionManager::connect( NodeCollectionPTR sources, const long rule_id = ( *connruledict_ )[ rule_name ]; ConnBuilder* cb = connbuilder_factories_.at( rule_id )->create( sources, targets, conn_spec, syn_specs ); - assert( cb != 0 ); + assert( cb != nullptr ); // at this point, all entries in conn_spec and syn_spec have been checked ALL_ENTRIES_ACCESSED( *conn_spec, "Connect", "Unread dictionary entries in conn_spec: " ); @@ -909,7 +909,7 @@ nest::ConnectionManager::get_num_target_data( const thread tid ) const size_t num_connections = 0; for ( synindex syn_id = 0; syn_id < connections_[ tid ].size(); ++syn_id ) { - if ( connections_[ tid ][ syn_id ] != NULL ) + if ( connections_[ tid ][ syn_id ] != nullptr ) { num_connections += source_table_.num_unique_sources( tid, syn_id ); } @@ -954,8 +954,8 @@ nest::ConnectionManager::get_connections( const DictionaryDatum& params ) const Token& source_t = params->lookup( names::source ); const Token& target_t = params->lookup( names::target ); const Token& syn_model_t = params->lookup( names::synapse_model ); - NodeCollectionPTR source_a = NodeCollectionPTR( 0 ); - NodeCollectionPTR target_a = NodeCollectionPTR( 0 ); + NodeCollectionPTR source_a = NodeCollectionPTR( nullptr ); + NodeCollectionPTR target_a = NodeCollectionPTR( nullptr ); long synapse_label = UNLABELED_CONNECTION; updateValue< long >( params, names::synapse_label, synapse_label ); @@ -1092,7 +1092,7 @@ nest::ConnectionManager::get_connections( std::deque< ConnectionID >& connectome std::deque< ConnectionID > conns_in_thread; ConnectorBase* connections = connections_[ tid ][ syn_id ]; - if ( connections != NULL ) + if ( connections != nullptr ) { // Passing target_node_id = 0 ignores target_node_id while getting connections. const size_t num_connections_in_thread = connections->size(); @@ -1182,7 +1182,7 @@ nest::ConnectionManager::get_connections( std::deque< ConnectionID >& connectome } const ConnectorBase* connections = connections_[ tid ][ syn_id ]; - if ( connections != NULL ) + if ( connections != nullptr ) { const size_t num_connections_in_thread = connections->size(); for ( index lcid = 0; lcid < num_connections_in_thread; ++lcid ) @@ -1254,7 +1254,7 @@ nest::ConnectionManager::get_source_node_ids_( const thread tid, std::vector< index >& sources ) { std::vector< index > source_lcids; - if ( connections_[ tid ][ syn_id ] != NULL ) + if ( connections_[ tid ][ syn_id ] != nullptr ) { connections_[ tid ][ syn_id ]->get_source_lcids( tid, tnode_id, source_lcids ); source_table_.get_source_node_ids( tid, syn_id, source_lcids, sources ); @@ -1314,7 +1314,7 @@ nest::ConnectionManager::sort_connections( const thread tid ) { for ( synindex syn_id = 0; syn_id < connections_[ tid ].size(); ++syn_id ) { - if ( connections_[ tid ][ syn_id ] != NULL ) + if ( connections_[ tid ][ syn_id ] != nullptr ) { connections_[ tid ][ syn_id ]->sort_connections( source_table_.get_thread_local_sources( tid )[ syn_id ] ); } @@ -1372,7 +1372,7 @@ nest::ConnectionManager::compute_compressed_secondary_recv_buffer_positions( con { std::vector< size_t >& positions = secondary_recv_buffer_pos_[ tid ][ syn_id ]; - if ( connections_[ tid ][ syn_id ] != NULL ) + if ( connections_[ tid ][ syn_id ] != nullptr ) { if ( not kernel().model_manager.get_connection_model( syn_id, tid ).is_primary() ) { @@ -1575,7 +1575,7 @@ nest::ConnectionManager::remove_disabled_connections( const thread tid ) for ( synindex syn_id = 0; syn_id < connectors.size(); ++syn_id ) { - if ( connectors[ syn_id ] == NULL ) + if ( connectors[ syn_id ] == nullptr ) { continue; } diff --git a/nestkernel/kernel_manager.cpp b/nestkernel/kernel_manager.cpp index b332b56a48..56e4bc6488 100644 --- a/nestkernel/kernel_manager.cpp +++ b/nestkernel/kernel_manager.cpp @@ -22,14 +22,14 @@ #include "kernel_manager.h" -nest::KernelManager* nest::KernelManager::kernel_manager_instance_ = 0; +nest::KernelManager* nest::KernelManager::kernel_manager_instance_ = nullptr; void nest::KernelManager::create_kernel_manager() { #pragma omp critical( create_kernel_manager ) { - if ( kernel_manager_instance_ == 0 ) + if ( kernel_manager_instance_ == nullptr ) { kernel_manager_instance_ = new KernelManager(); assert( kernel_manager_instance_ ); diff --git a/nestkernel/layer_impl.h b/nestkernel/layer_impl.h index 228361835c..07112a6189 100644 --- a/nestkernel/layer_impl.h +++ b/nestkernel/layer_impl.h @@ -117,7 +117,7 @@ Layer< D >::connect( NodeCollectionPTR source_nc, // We need to extract the real pointer here to be able to cast to the // dimension-specific subclass. AbstractLayer* target_abs = target_layer.get(); - assert( target_abs != 0 ); + assert( target_abs != nullptr ); try { @@ -173,7 +173,7 @@ Layer< D >::get_global_positions_ntree( std::bitset< D > periodic, do_get_global_positions_ntree_( node_collection ); // Do not use cache since the periodic bits and extents were altered. - cached_ntree_md_ = NodeCollectionMetadataPTR( 0 ); + cached_ntree_md_ = NodeCollectionMetadataPTR( nullptr ); return cached_ntree_; } diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 041de0d811..27d1da9b4b 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -452,7 +452,7 @@ ModelManager::clear_node_models_() // init() for ( auto&& node_model : node_models_ ) { - if ( node_model != 0 ) + if ( node_model != nullptr ) { delete node_model; } @@ -476,7 +476,7 @@ ModelManager::clear_connection_models_() { for ( auto&& connection_model : connection_models_[ t ] ) { - if ( connection_model != 0 ) + if ( connection_model != nullptr ) { delete connection_model; } @@ -497,7 +497,7 @@ ModelManager::calibrate( const TimeConverter& tc ) { for ( auto&& connection_model : connection_models_[ t ] ) { - if ( connection_model != 0 ) + if ( connection_model != nullptr ) { connection_model->calibrate( tc ); } diff --git a/sli/aggregatedatum.h b/sli/aggregatedatum.h index fb625252a4..d5b710ef53 100644 --- a/sli/aggregatedatum.h +++ b/sli/aggregatedatum.h @@ -117,7 +117,7 @@ class AggregateDatum : public TypedDatum< slt >, public C static void operator delete( void* p, size_t size ) { - if ( p == NULL ) + if ( p == nullptr ) { return; } diff --git a/sli/dictstack.h b/sli/dictstack.h index 49812e0262..e3c5c6ad60 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -95,7 +95,7 @@ class DictionaryStack Name::handle_t key = n.toIndex(); if ( key >= cache_.size() ) { - cache_.resize( Name::num_handles() + 100, 0 ); + cache_.resize( Name::num_handles() + 100, nullptr ); } cache_[ key ] = result; } @@ -106,7 +106,7 @@ class DictionaryStack Name::handle_t key = n.toIndex(); if ( key >= basecache_.size() ) { - basecache_.resize( Name::num_handles() + 100, 0 ); + basecache_.resize( Name::num_handles() + 100, nullptr ); } basecache_[ key ] = result; } @@ -121,7 +121,7 @@ class DictionaryStack Name::handle_t key = n.toIndex(); if ( key < cache_.size() ) { - cache_[ key ] = 0; + cache_[ key ] = nullptr; } } @@ -131,7 +131,7 @@ class DictionaryStack Name::handle_t key = n.toIndex(); if ( key < basecache_.size() ) { - basecache_[ key ] = 0; + basecache_[ key ] = nullptr; } } @@ -155,7 +155,7 @@ class DictionaryStack const size_t cache_size = cache_.size(); for ( size_t i = 0; i < cache_size; ++i ) { - cache_[ i ] = 0; + cache_[ i ] = nullptr; } } diff --git a/sli/dictutils.h b/sli/dictutils.h index a4a5198c68..6cbcf55701 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -92,14 +92,14 @@ get_double_in_range( const DictionaryDatum& d, Name const n, double min, double DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); double x = 0.0; - if ( dd != 0 ) + if ( dd != nullptr ) { x = dd->get(); } else { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == 0 ) + if ( id == nullptr ) { throw TypeMismatch(); } @@ -156,14 +156,14 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); long x = 0; - if ( dd != 0 ) + if ( dd != nullptr ) { x = dd->get(); } else { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == 0 ) + if ( id == nullptr ) { throw TypeMismatch(); } @@ -302,7 +302,7 @@ append_property( DictionaryDatum& d, Name propname, const PropT& prop ) assert( not t.empty() ); ArrayDatum* arrd = dynamic_cast< ArrayDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); Token prop_token( prop ); arrd->push_back_dont_clone( prop_token ); @@ -320,7 +320,7 @@ append_property< std::vector< double > >( DictionaryDatum& d, Name propname, con assert( not t.empty() ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } @@ -338,7 +338,7 @@ append_property< std::vector< long > >( DictionaryDatum& d, Name propname, const assert( not t.empty() ); IntVectorDatum* arrd = dynamic_cast< IntVectorDatum* >( t.datum() ); - assert( arrd != 0 ); + assert( arrd != nullptr ); ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } diff --git a/sli/functiondatum.h b/sli/functiondatum.h index ca3555e26f..dcf6cc4ca8 100644 --- a/sli/functiondatum.h +++ b/sli/functiondatum.h @@ -137,7 +137,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > equals( Datum const* dat ) const { const FunctionDatum* fd = dynamic_cast< FunctionDatum* >( const_cast< Datum* >( dat ) ); - if ( fd == NULL ) + if ( fd == nullptr ) { return false; } @@ -166,7 +166,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > static void operator delete( void* p, size_t size ) { - if ( p == NULL ) + if ( p == nullptr ) { return; } diff --git a/sli/gnureadline.cc b/sli/gnureadline.cc index 8cd7d5a87d..ae0bece766 100644 --- a/sli/gnureadline.cc +++ b/sli/gnureadline.cc @@ -57,9 +57,9 @@ GNUReadline::GNUReadlineFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); char* line_read = readline( sd->c_str() ); - if ( line_read == NULL ) + if ( line_read == nullptr ) { // We have received EOF (Ctrl-D), so we quit. std::cout << std::endl; @@ -97,7 +97,7 @@ GNUReadline::GNUAddhistoryFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); i->EStack.pop(); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); add_history( sd->c_str() ); char* home = std::getenv( "HOME" ); std::string hist_file = std::string( home ) + std::string( "/.nest_history" ); diff --git a/sli/interpret.cc b/sli/interpret.cc index f04b3cd05e..df60ef95f6 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -374,10 +374,10 @@ SLIInterpreter::SLIInterpreter( void ) , cycle_guard( false ) , cycle_restriction( 0 ) , verbositylevel( M_INFO ) - , statusdict( 0 ) - , errordict( 0 ) - , DStack( 0 ) - , parse( 0 ) + , statusdict( nullptr ) + , errordict( nullptr ) + , DStack( nullptr ) + , parse( nullptr ) , ilookup_name( "::lookup" ) , ipop_name( "::pop" ) , isetcallback_name( "::setcallback" ) @@ -528,7 +528,7 @@ SLIInterpreter::addmodule( SLIModule* m ) if ( not( m->commandstring().empty() ) ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( baselookup( commandstring_name ).datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); ad->push_back( new StringDatum( m->commandstring() ) ); } } @@ -543,7 +543,7 @@ SLIInterpreter::addlinkedusermodule( SLIModule* m ) if ( not( m->commandstring().empty() ) ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( baselookup( commandstring_name ).datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); ad->push_back( new StringDatum( m->commandstring() ) ); } } @@ -596,7 +596,7 @@ SLIInterpreter::raiseerror( std::exception& err ) { Name caller = getcurrentname(); - assert( errordict != NULL ); + assert( errordict != nullptr ); errordict->insert( "command", EStack.top() ); // store the func/trie that caused the error. // SLIException provide addtional information @@ -623,7 +623,7 @@ SLIInterpreter::raiseerror( Name cmd, Name err ) // All error related symbols are now in their correct dictionary, // the error dictionary $errordict ( see Bug #4) - assert( errordict != NULL ); + assert( errordict != nullptr ); if ( errordict->lookup( newerror_name ) == baselookup( false_name ) ) { @@ -699,14 +699,14 @@ SLIInterpreter::print_error( Token cmd ) // Command information is only printed if the // command is of trietype - if ( command.datum() != NULL ) + if ( command.datum() != nullptr ) { if ( command->gettypename() == Name( "trietype" ) ) { msg << "\n\nCandidates for " << command << " are:\n"; TrieDatum* trie = dynamic_cast< TrieDatum* >( command.datum() ); - assert( trie != NULL ); + assert( trie != nullptr ); trie->get().info( msg ); } @@ -724,7 +724,7 @@ SLIInterpreter::print_error( Token cmd ) void SLIInterpreter::raiseagain( void ) { - assert( errordict != NULL ); + assert( errordict != nullptr ); if ( errordict->known( commandname_name ) ) { @@ -839,7 +839,7 @@ SLIInterpreter::message( std::ostream& out, { const unsigned buflen = 30; char timestring[ buflen + 1 ] = ""; - const time_t tm = std::time( NULL ); + const time_t tm = std::time( nullptr ); std::strftime( timestring, buflen, "%b %d %H:%M:%S", std::localtime( &tm ) ); @@ -931,12 +931,12 @@ Name SLIInterpreter::getcurrentname( void ) const { FunctionDatum* func = dynamic_cast< FunctionDatum* >( EStack.top().datum() ); - if ( func != NULL ) + if ( func != nullptr ) { return ( func->getname() ); } TrieDatum* trie = dynamic_cast< TrieDatum* >( EStack.top().datum() ); - if ( trie != NULL ) + if ( trie != nullptr ) { return ( trie->getname() ); } @@ -1000,13 +1000,13 @@ SLIInterpreter::stack_backtrace( int n ) } FunctionDatum* fd = dynamic_cast< FunctionDatum* >( EStack.pick( p ).datum() ); - if ( fd != 0 ) + if ( fd != nullptr ) { fd->backtrace( this, p ); continue; } NameDatum* nd = dynamic_cast< NameDatum* >( EStack.pick( p ).datum() ); - if ( nd != 0 ) + if ( nd != nullptr ) { std::cerr << "While executing: "; nd->print( std::cerr ); @@ -1014,7 +1014,7 @@ SLIInterpreter::stack_backtrace( int n ) continue; } TrieDatum* td = dynamic_cast< TrieDatum* >( EStack.pick( p ).datum() ); - if ( td != 0 ) + if ( td != nullptr ) { std::cerr << "While executing: "; td->print( std::cerr ); diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 0571d0fc85..abfd2824bb 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -67,11 +67,11 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != 0 ); + assert( ad != nullptr ); if ( ad->size() == 1 ) // Construct an array of elements 1 ... N { IntegerDatum* nd = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); - if ( nd != 0 ) + if ( nd != nullptr ) { long n = nd->get(); ad->erase(); @@ -106,7 +106,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) { long n = 1 + n2d->get() - n1d->get(); @@ -130,7 +130,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) { long n = 1 + static_cast< long >( n2d->get() - n1d->get() ); @@ -161,7 +161,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) && ( n3d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) { long di = n3d->get(); long start = n1d->get(); @@ -192,7 +192,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) && ( n3d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) { double di = n3d->get(); double start = n1d->get(); @@ -240,11 +240,11 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != 0 ); + assert( ad != nullptr ); if ( ad->size() == 1 ) // Construct an array of elements 1 ... N { IntegerDatum* nd = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); - if ( nd != 0 ) + if ( nd != nullptr ) { long n = nd->get(); if ( n < 0 ) @@ -286,7 +286,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) { const long start = n1d->get(); const long stop = n2d->get(); @@ -310,7 +310,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) { double start = n1d->get(); double stop = n2d->get(); @@ -338,7 +338,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) && ( n3d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) { long di = n3d->get(); long start = n1d->get(); @@ -372,7 +372,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != 0 ) && ( n2d != 0 ) && ( n3d != 0 ) ) + if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) { double di = n3d->get(); double start = n1d->get(); @@ -421,7 +421,7 @@ SLIArrayModule::ReverseFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != 0 ); + assert( ad != nullptr ); ad->reverse(); i->EStack.pop(); } @@ -447,7 +447,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != 0 ); + assert( ad != nullptr ); ArrayDatum* ta = new ArrayDatum(); Token at( ta ); @@ -457,7 +457,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token const* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != NULL ) + if ( ad1 != nullptr ) { size += ad1->size(); } @@ -480,7 +480,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != NULL ) + if ( ad1 != nullptr ) { if ( ad1->references() > 1 ) { @@ -508,7 +508,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token const* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != NULL ) + if ( ad1 != nullptr ) { for ( Token const* t1 = ad1->begin(); t1 != ad1->end(); ++t1 ) { @@ -648,10 +648,10 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* sd = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( sd != 0 ); + assert( sd != nullptr ); ArrayDatum* hd = dynamic_cast< ArrayDatum* >( sd->begin()->datum() ); - assert( hd != 0 ); + assert( hd != nullptr ); // size of source first level size_t m = sd->size(); @@ -664,7 +664,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const ArrayDatum* td = new ArrayDatum(); - assert( td != 0 ); + assert( td != nullptr ); Token tt( td ); @@ -675,7 +675,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const for ( size_t j = 0; j < n; j++ ) { hd = new ArrayDatum(); - assert( td != 0 ); + assert( td != nullptr ); hd->reserve( m ); @@ -687,7 +687,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const hd = dynamic_cast< ArrayDatum* >( sr->datum() ); // raiseerror instead - assert( hd != 0 ); + assert( hd != nullptr ); Token* sc; Token* tr; @@ -698,7 +698,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const ArrayDatum* trd = dynamic_cast< ArrayDatum* >( tr->datum() ); // raiseerror instead - assert( trd != 0 ); + assert( trd != nullptr ); trd->push_back( *sc ); } @@ -719,11 +719,11 @@ SLIArrayModule::PartitionFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 2 ); IntegerDatum* dd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( dd != NULL ); + assert( dd != nullptr ); IntegerDatum* nd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( nd != NULL ); + assert( nd != nullptr ); ArrayDatum* source = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); - assert( source != 0 ); + assert( source != nullptr ); ArrayDatum* target = new ArrayDatum; long n = nd->get(); @@ -805,7 +805,7 @@ SLIArrayModule::ArrayloadFunction::execute( SLIInterpreter* i ) const at.move( i->OStack.top() ); i->OStack.pop(); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( at.datum() ); - assert( ad != 0 ); + assert( ad != nullptr ); i->EStack.pop(); int arraysize = ad->size(); i->OStack.reserve_token( arraysize ); @@ -861,7 +861,7 @@ SLIArrayModule::ArraystoreFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != NULL ); + assert( id != nullptr ); long n = id->get(); if ( n >= 0 ) @@ -938,13 +938,13 @@ void SLIArrayModule::IMapFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1036,7 +1036,7 @@ SLIArrayModule::IMapFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != NULL ) + if ( proc != nullptr ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1058,13 +1058,13 @@ void SLIArrayModule::IMap_ivFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1174,7 +1174,7 @@ SLIArrayModule::IMap_ivFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != NULL ) + if ( proc != nullptr ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1197,13 +1197,13 @@ void SLIArrayModule::IMap_dvFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1309,7 +1309,7 @@ SLIArrayModule::IMap_dvFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != NULL ) + if ( proc != nullptr ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1388,7 +1388,7 @@ SLIArrayModule::MapFunction::execute( SLIInterpreter* i ) const { i->EStack.pop(); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != NULL ); + assert( proc != nullptr ); if ( proc->size() == 0 ) { @@ -1426,7 +1426,7 @@ SLIArrayModule::ValidFunction::execute( SLIInterpreter* i ) const { assert( i->OStack.load() > 0 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); i->OStack.push( ad->valid() ); i->EStack.pop(); @@ -1436,13 +1436,13 @@ void SLIArrayModule::IMapIndexedFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); std::cerr << "During MapIndexed at iteration " << count->get() << "." << std::endl; @@ -1538,7 +1538,7 @@ SLIArrayModule::IMapIndexedFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != NULL ) + if ( proc != nullptr ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1563,7 +1563,7 @@ SLIArrayModule::MapIndexedFunction::execute( SLIInterpreter* i ) const { i->EStack.pop(); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != NULL ); + assert( proc != nullptr ); if ( proc->size() == 0 ) { @@ -1588,13 +1588,13 @@ void SLIArrayModule::IMapThreadFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != NULL ); + assert( id != nullptr ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != NULL ); + assert( pd != nullptr ); std::cerr << "During MapThread at iteration " << count->get() << "." << std::endl; @@ -1710,7 +1710,7 @@ SLIArrayModule::IMapThreadFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( procd != NULL ) + if ( procd != nullptr ) { procd->list( std::cerr, " ", proccount ); std::cerr << std::endl; @@ -1756,7 +1756,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const { assert( i->OStack.load() >= 2 ); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != NULL ); + assert( proc != nullptr ); if ( proc->size() == 0 ) { @@ -1767,13 +1767,13 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const } ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); if ( ad->size() > 0 ) { // check if the components are arrays of equal length. ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( ad->get( 0 ).datum() ); - if ( ad1 == NULL ) + if ( ad1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -1782,7 +1782,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const for ( size_t j = 1; j < ad->size(); ++j ) { ArrayDatum* ad2 = dynamic_cast< ArrayDatum* >( ad->get( j ).datum() ); - if ( ad2 == NULL ) + if ( ad2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -1829,7 +1829,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const } ArrayDatum* source = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); - if ( source == NULL ) + if ( source == nullptr ) { i->message( SLIInterpreter::M_ERROR, "Put", "First argument must be an array." ); i->message( SLIInterpreter::M_ERROR, "Put", "Usage: [array] [d1 ...dn] obj Put -> [array]" ); @@ -1840,7 +1840,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const ArrayDatum* pos = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( pos == NULL ) + if ( pos == nullptr ) { i->message( SLIInterpreter::M_ERROR, "Put", @@ -1853,9 +1853,9 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const for ( Token* t = pos->begin(); t != pos->end(); ++t ) { - assert( t != NULL ); + assert( t != nullptr ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( idx == NULL ) + if ( idx == nullptr ) { i->message( SLIInterpreter::M_ERROR, "Put", "Non integer index found." ); i->message( SLIInterpreter::M_ERROR, "Put", "Source array is unchanged." ); @@ -1884,7 +1884,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const if ( t < pos->end() - 1 ) { source = dynamic_cast< ArrayDatum* >( ( *source )[ j ].datum() ); - if ( source == NULL ) + if ( source == nullptr ) { i->message( SLIInterpreter::M_ERROR, "Put", "Dimensions of index and array do not match." ); i->message( SLIInterpreter::M_ERROR, "Put", "Source array is unchanged." ); @@ -2078,37 +2078,37 @@ SLIArrayModule::AreaFunction::execute( SLIInterpreter* i ) const // i->raiseerror(i->ArgumentTypeError); // return; // } - if ( s_w_d == NULL ) + if ( s_w_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_y_d == NULL ) + if ( s_y_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_x_d == NULL ) + if ( s_x_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_h_d == NULL ) + if ( a_h_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_w_d == NULL ) + if ( a_w_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_y_d == NULL ) + if ( a_y_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_x_d == NULL ) + if ( a_x_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2347,32 +2347,32 @@ SLIArrayModule::Area2Function::execute( SLIInterpreter* i ) const // i->raiseerror(i->ArgumentTypeError); // return; // } - if ( s_y_d == NULL ) + if ( s_y_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_x_d == NULL ) + if ( s_x_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_h_d == NULL ) + if ( a_h_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_w_d == NULL ) + if ( a_w_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_y_d == NULL ) + if ( a_y_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_x_d == NULL ) + if ( a_x_d == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2446,7 +2446,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const IntegerDatum* x = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* y = dynamic_cast< IntegerDatum* >( i->OStack.pick( 2 ).datum() ); - if ( w == NULL ) + if ( w == nullptr ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2454,7 +2454,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const return; } - if ( x == NULL ) + if ( x == nullptr ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2462,7 +2462,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const return; } - if ( y == NULL ) + if ( y == nullptr ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2516,7 +2516,7 @@ SLIArrayModule::Cv2dFunction::execute( SLIInterpreter* i ) const IntegerDatum* w = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); IntegerDatum* in = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( w == NULL ) + if ( w == nullptr ) { i->message( SLIInterpreter::M_ERROR, "cv2d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv2d", "Usage: i w cv2d" ); @@ -2524,7 +2524,7 @@ SLIArrayModule::Cv2dFunction::execute( SLIInterpreter* i ) const return; } - if ( in == NULL ) + if ( in == nullptr ) { i->message( SLIInterpreter::M_ERROR, "cv2d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv2d", "Usage: i w cv2d" ); @@ -2567,7 +2567,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const } ArrayDatum* a = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( a == NULL ) + if ( a == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument must be an array" ); i->raiseerror( i->ArgumentTypeError ); @@ -2575,7 +2575,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const } IntegerDatum* tmp = dynamic_cast< IntegerDatum* >( a->begin()->datum() ); - if ( tmp == NULL ) + if ( tmp == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2587,7 +2587,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const while ( pos < a->size() ) { tmp2 = dynamic_cast< IntegerDatum* >( a->get( pos ).datum() ); - if ( tmp2 == NULL ) + if ( tmp2 == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2629,7 +2629,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const } ArrayDatum* a = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( a == NULL ) + if ( a == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument must be an array" ); i->raiseerror( i->ArgumentTypeError ); @@ -2638,7 +2638,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const IntegerDatum* tmp = dynamic_cast< IntegerDatum* >( a->begin()->datum() ); - if ( tmp == NULL ) + if ( tmp == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2650,7 +2650,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const while ( pos < a->size() ) { tmp2 = dynamic_cast< IntegerDatum* >( a->get( pos ).datum() ); - if ( tmp2 == NULL ) + if ( tmp2 == nullptr ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2942,7 +2942,7 @@ SLIArrayModule::IntVector2ArrayFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2962,13 +2962,13 @@ SLIArrayModule::Add_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == 0 ) + if ( ivd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == 0 ) + if ( ivd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3000,13 +3000,13 @@ SLIArrayModule::Add_i_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3034,7 +3034,7 @@ SLIArrayModule::Neg_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3061,13 +3061,13 @@ SLIArrayModule::Sub_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == 0 ) + if ( ivd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == 0 ) + if ( ivd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3099,13 +3099,13 @@ SLIArrayModule::Mul_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == 0 ) + if ( ivd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == 0 ) + if ( ivd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3138,13 +3138,13 @@ SLIArrayModule::Mul_i_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3172,13 +3172,13 @@ SLIArrayModule::Mul_d_ivFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == 0 ) + if ( dd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3206,13 +3206,13 @@ SLIArrayModule::Div_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == 0 ) + if ( ivd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == 0 ) + if ( ivd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3252,7 +3252,7 @@ SLIArrayModule::Length_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3275,13 +3275,13 @@ SLIArrayModule::Add_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == 0 ) + if ( dvd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == 0 ) + if ( dvd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3313,13 +3313,13 @@ SLIArrayModule::Sub_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == 0 ) + if ( dvd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == 0 ) + if ( dvd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3351,13 +3351,13 @@ SLIArrayModule::Add_d_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == 0 ) + if ( dd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( dvd == 0 ) + if ( dvd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3387,13 +3387,13 @@ SLIArrayModule::Mul_d_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == 0 ) + if ( dd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( dvd == 0 ) + if ( dvd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3423,7 +3423,7 @@ SLIArrayModule::Neg_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd == 0 ) + if ( dvd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3451,7 +3451,7 @@ SLIArrayModule::Inv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd == 0 ) + if ( dvd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3486,13 +3486,13 @@ SLIArrayModule::Mul_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == 0 ) + if ( dvd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == 0 ) + if ( dvd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3524,13 +3524,13 @@ SLIArrayModule::Div_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == 0 ) + if ( dvd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == 0 ) + if ( dvd2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3570,7 +3570,7 @@ SLIArrayModule::Length_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == 0 ) + if ( dvd1 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3592,13 +3592,13 @@ SLIArrayModule::Get_dv_iFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd == 0 ) + if ( dvd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3625,13 +3625,13 @@ SLIArrayModule::Get_iv_iFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == 0 ) + if ( vd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3658,13 +3658,13 @@ SLIArrayModule::Get_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* id = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == 0 ) + if ( vd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3698,13 +3698,13 @@ SLIArrayModule::Get_dv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* id = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == 0 ) + if ( id == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* vd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == 0 ) + if ( vd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3739,19 +3739,19 @@ SLIArrayModule::Put_dv_i_dFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* val = dynamic_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - if ( val == 0 ) + if ( val == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntegerDatum* idxd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idxd == 0 ) + if ( idxd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* vecd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 2 ).datum() ); - if ( vecd == 0 ) + if ( vecd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3774,19 +3774,19 @@ SLIArrayModule::Put_iv_i_iFunction::execute( SLIInterpreter* i ) const { IntegerDatum* val = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( val == 0 ) + if ( val == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntegerDatum* idxd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idxd == 0 ) + if ( idxd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vecd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 2 ).datum() ); - if ( vecd == 0 ) + if ( vecd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3813,7 +3813,7 @@ SLIArrayModule::DoubleVector2ArrayFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* ivd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == 0 ) + if ( ivd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3833,7 +3833,7 @@ SLIArrayModule::Zeros_dvFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == 0 ) + if ( num == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3858,7 +3858,7 @@ SLIArrayModule::Ones_dvFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == 0 ) + if ( num == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3883,7 +3883,7 @@ SLIArrayModule::Zeros_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == 0 ) + if ( num == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3908,7 +3908,7 @@ SLIArrayModule::Ones_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == 0 ) + if ( num == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -4006,7 +4006,7 @@ void SLIArrayModule::Iforall_ivFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forall (IntVector) at iteration " << count->get() << "." << std::endl; } @@ -4082,7 +4082,7 @@ void SLIArrayModule::Iforall_dvFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != NULL ); + assert( count != nullptr ); std::cerr << "During forall (DoubleVector) at iteration " << count->get() << "." << std::endl; } diff --git a/sli/slidata.cc b/sli/slidata.cc index 546d14ac74..92d14393a5 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -62,9 +62,9 @@ Get_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != NULL ); + assert( idx != nullptr ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -87,7 +87,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ArrayDatum* idx = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( idx == NULL ) + if ( idx == nullptr ) { i->message( SLIInterpreter::M_ERROR, "get_a_a", "Second argument must be an array of indices." ); i->message( SLIInterpreter::M_ERROR, "get_a_a", "Usage: [a] [i1 .. in] get -> [a[i1] ... a[in]]" ); @@ -96,7 +96,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const } ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( obj == NULL ) + if ( obj == nullptr ) { i->message( SLIInterpreter::M_ERROR, "get_a_a", "Usage: [a] [i1 .. in] get -> [a[i1] ... a[in]]" ); i->message( SLIInterpreter::M_ERROR, "get_a_a", "First argument must be an array." ); @@ -110,7 +110,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const for ( Token* t = idx->begin(); t != idx->end(); ++t ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( id == NULL ) + if ( id == nullptr ) { std::ostringstream sout; @@ -154,9 +154,9 @@ Get_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != NULL ); + assert( idx != nullptr ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -179,9 +179,9 @@ Get_lpFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != NULL ); + assert( idx != nullptr ); LitprocedureDatum* obj = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) { @@ -204,7 +204,7 @@ Append_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); obj->push_back_move( i->OStack.top() ); @@ -219,7 +219,7 @@ Append_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); obj->push_back_move( i->OStack.top() ); @@ -251,7 +251,7 @@ Append_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != NULL && id != NULL ); + assert( sd != nullptr && id != nullptr ); ( *sd ) += static_cast< char >( id->get() ); @@ -284,7 +284,7 @@ Join_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - if ( s1 == NULL || s2 == NULL ) + if ( s1 == nullptr || s2 == nullptr ) { i->message( SLIInterpreter::M_ERROR, "join_s", "Usage: (string1) (string2) join_s" ); i->raiseerror( i->ArgumentTypeError ); @@ -307,7 +307,7 @@ Join_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != NULL && a2 != NULL ); + assert( a1 != nullptr && a2 != nullptr ); a1->append_move( *a2 ); @@ -325,7 +325,7 @@ Join_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* a1 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); ProcedureDatum* a2 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != NULL && a2 != NULL ); + assert( a1 != nullptr && a2 != nullptr ); a1->append_move( *a2 ); @@ -355,7 +355,7 @@ Insert_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && s2 != NULL ); + assert( s1 != nullptr && id != nullptr && s2 != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -391,7 +391,7 @@ InsertElement_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && c != NULL ); + assert( s1 != nullptr && id != nullptr && c != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -430,7 +430,7 @@ Prepend_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && c != NULL ); + assert( s1 != nullptr && c != nullptr ); s1->insert( ( size_t ) 0, 1, static_cast< char >( c->get() ) ); @@ -447,7 +447,7 @@ Insert_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != NULL && id != NULL && a2 != NULL ); + assert( a1 != nullptr && id != nullptr && a2 != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) { @@ -470,7 +470,7 @@ InsertElement_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != NULL && id != NULL ); + assert( a1 != nullptr && id != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) { @@ -494,7 +494,7 @@ Prepend_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != NULL ); + assert( a1 != nullptr ); a1->insert_move( 0, i->OStack.top() ); @@ -511,7 +511,7 @@ Prepend_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* a1 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != NULL ); + assert( a1 != nullptr ); a1->insert_move( 0, i->OStack.top() ); @@ -544,7 +544,7 @@ Replace_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && n != NULL && s2 != NULL ); + assert( s1 != nullptr && id != nullptr && n != nullptr && s2 != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -576,7 +576,7 @@ Replace_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && n != NULL && s2 != NULL ); + assert( s1 != nullptr && id != nullptr && n != nullptr && s2 != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -621,7 +621,7 @@ Erase_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && n != NULL ); + assert( s1 != nullptr && id != nullptr && n != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -652,7 +652,7 @@ Erase_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && n != NULL ); + assert( s1 != nullptr && id != nullptr && n != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -683,7 +683,7 @@ Erase_pFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && n != NULL ); + assert( s1 != nullptr && id != nullptr && n != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -715,7 +715,7 @@ Put_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && id != NULL && cd != NULL ); + assert( s1 != nullptr && id != nullptr && cd != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -739,7 +739,7 @@ Put_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -763,7 +763,7 @@ Put_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* ad = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -787,7 +787,7 @@ Put_lpFunction::execute( SLIInterpreter* i ) const LitprocedureDatum* ad = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -819,7 +819,7 @@ Length_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->length() ) ); @@ -845,7 +845,7 @@ Length_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->size() ) ); @@ -871,7 +871,7 @@ Length_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* s = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->size() ) ); @@ -901,7 +901,7 @@ Length_lpFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); LitprocedureDatum* s = dynamic_cast< LitprocedureDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->size() ) ); @@ -931,7 +931,7 @@ Capacity_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->capacity() ) ); @@ -958,7 +958,7 @@ Size_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->size() ) ); @@ -983,7 +983,7 @@ Reserve_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1018,7 +1018,7 @@ Resize_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1040,7 +1040,7 @@ Empty_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); if ( ad->empty() ) { @@ -1061,7 +1061,7 @@ References_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); Token t( new IntegerDatum( ad->references() ) ); @@ -1084,7 +1084,7 @@ Shrink_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); if ( ad->shrink() ) { @@ -1104,7 +1104,7 @@ Capacity_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->capacity() ) ); @@ -1119,7 +1119,7 @@ Size_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != NULL ); + assert( s != nullptr ); Token t( new IntegerDatum( s->size() ) ); @@ -1135,7 +1135,7 @@ Reserve_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( id->get() >= 0 ) { @@ -1158,7 +1158,7 @@ Resize_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != NULL && id != NULL ); + assert( ad != nullptr && id != nullptr ); if ( id->get() >= 0 ) { @@ -1182,7 +1182,7 @@ Empty_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); if ( ad->empty() ) { @@ -1229,7 +1229,7 @@ Getinterval_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != NULL && id != NULL && cd != NULL ); + assert( sd != nullptr && id != nullptr && cd != nullptr ); if ( cd->get() >= 0 ) { @@ -1261,7 +1261,7 @@ Getinterval_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* sd = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != NULL && id != NULL && cd != NULL ); + assert( sd != nullptr && id != nullptr && cd != nullptr ); if ( cd->get() >= 0 ) { @@ -1293,7 +1293,7 @@ Cvx_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new ProcedureDatum( *obj ) ); t->set_executable(); i->OStack.top().swap( t ); @@ -1305,7 +1305,7 @@ Cvlit_nFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); NameDatum* obj = dynamic_cast< NameDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new LiteralDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1317,7 +1317,7 @@ Cvn_lFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); LiteralDatum* obj = dynamic_cast< LiteralDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new NameDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1329,7 +1329,7 @@ Cvn_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new NameDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1341,7 +1341,7 @@ Cvlit_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new ArrayDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1356,7 +1356,7 @@ Cvlp_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new LitprocedureDatum( *obj ) ); t->set_executable(); i->OStack.top().swap( t ); @@ -1370,7 +1370,7 @@ Cvi_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new IntegerDatum( std::atoi( obj->c_str() ) ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1383,7 +1383,7 @@ Cvd_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); Token t( new DoubleDatum( std::atof( obj->c_str() ) ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1397,10 +1397,10 @@ Get_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != NULL ); + assert( idx != nullptr ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != NULL ); + assert( obj != nullptr ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -1439,7 +1439,7 @@ Search_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && s2 != NULL ); + assert( s1 != nullptr && s2 != nullptr ); size_t p = s1->find( *s2 ); @@ -1474,7 +1474,7 @@ Search_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* s1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != NULL && s2 != NULL ); + assert( s1 != nullptr && s2 != nullptr ); Token* p = std::search( s1->begin(), s1->end(), s2->begin(), s2->end() ); diff --git a/sli/slidict.cc b/sli/slidict.cc index def7bcf923..1facbd6541 100644 --- a/sli/slidict.cc +++ b/sli/slidict.cc @@ -105,10 +105,10 @@ DictputFunction::execute( SLIInterpreter* i ) const { // call: dict key val DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 2 ).datum() ); - if ( dict != 0 ) + if ( dict != nullptr ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 1 ).datum() ); - if ( key != 0 ) + if ( key != nullptr ) { ( *dict )->insert_move( *key, i->OStack.top() ); #ifdef DICTSTACK_CACHE @@ -172,10 +172,10 @@ DictgetFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() >= 2 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dict != 0 ) + if ( dict != nullptr ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - if ( key != 0 ) + if ( key != nullptr ) { Token value = ( *dict )->lookup2( *key ); i->EStack.pop(); // never forget me @@ -235,8 +235,8 @@ DictinfoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); - assert( outd != NULL ); + assert( dict != nullptr ); + assert( outd != nullptr ); i->EStack.pop(); ( *dict )->info( **outd ); i->OStack.pop( 2 ); @@ -263,7 +263,7 @@ Length_dFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); i->EStack.pop(); Token st( new IntegerDatum( ( *dict )->size() ) ); i->OStack.pop(); @@ -278,7 +278,7 @@ Empty_DFunction::execute( SLIInterpreter* i ) const DictionaryDatum const* const dd = dynamic_cast< DictionaryDatum const* const >( i->OStack.top().datum() ); - assert( dd != NULL ); + assert( dd != nullptr ); i->OStack.push_by_pointer( new BoolDatum( ( *dd )->empty() ) ); @@ -397,7 +397,7 @@ DicttopinfoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( outd != NULL ); + assert( outd != nullptr ); i->EStack.pop(); i->DStack->top_info( **outd ); i->OStack.pop(); @@ -426,7 +426,7 @@ WhoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( outd != NULL ); + assert( outd != nullptr ); i->EStack.pop(); i->DStack->info( **outd ); i->OStack.pop(); @@ -455,7 +455,7 @@ DictbeginFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() > 0 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - if ( dict != NULL ) + if ( dict != nullptr ) { i->EStack.pop(); i->DStack->push( *dict ); @@ -550,10 +550,10 @@ UndefFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() > 1 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dict != NULL ) + if ( dict != nullptr ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - if ( key != NULL ) + if ( key != nullptr ) { i->EStack.pop(); #ifdef DICTSTACK_CACHE @@ -641,7 +641,7 @@ DictconstructFunction::execute( SLIInterpreter* i ) const DictionaryDatum* dictd = new DictionaryDatum( new Dictionary ); Token dict( dictd ); - LiteralDatum* key = NULL; + LiteralDatum* key = nullptr; static Token mark = i->baselookup( i->mark_name ); size_t n = 0; //!< pick(1) is the first literal, then we count in steps of 2 @@ -649,7 +649,7 @@ DictconstructFunction::execute( SLIInterpreter* i ) const { Token& val = ( i->OStack.pick( n ) ); key = dynamic_cast< LiteralDatum* >( i->OStack.pick( n + 1 ).datum() ); - if ( key == NULL ) + if ( key == nullptr ) { i->message( 30, "DictConstruct", "Literal expected. Maybe initializer list is in the wrong order." ); i->raiseerror( i->ArgumentTypeError ); @@ -722,7 +722,7 @@ CleardictFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); #ifdef DICTSTACK_CACHE if ( ( *dict )->is_on_dictstack() ) { @@ -762,7 +762,7 @@ ClonedictFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); i->OStack.push( DictionaryDatum( new Dictionary( *( *dict ) ) ) ); i->EStack.pop(); // never forget me @@ -831,7 +831,7 @@ Cva_dFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); ArrayDatum* ad = new ArrayDatum(); ad->reserve( ( *dict )->size() * 2 ); @@ -882,7 +882,7 @@ KeysFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); ArrayDatum* ad = new ArrayDatum(); for ( TokenMap::const_iterator t = ( *dict )->begin(); t != ( *dict )->end(); ++t ) @@ -932,7 +932,7 @@ ValuesFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != NULL ); + assert( dict != nullptr ); ArrayDatum* ad = new ArrayDatum(); for ( TokenMap::const_iterator t = ( *dict )->begin(); t != ( *dict )->end(); ++t ) @@ -948,7 +948,7 @@ RestoredstackFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); TokenArray ta = *ad; DictionaryStack* olddstack = i->DStack; // copy current dstack i->DStack = new DictionaryStack; diff --git a/sli/sligraphics.cc b/sli/sligraphics.cc index 7b1c6c9a18..76bf7bf75e 100644 --- a/sli/sligraphics.cc +++ b/sli/sligraphics.cc @@ -81,12 +81,12 @@ SLIgraphics::ReadPGMFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == NULL ) + if ( sd == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; } - std::istream* in = NULL; + std::istream* in = nullptr; std::vector< long > image; // for the image parameters: width, height, maxval int width = 0, height = 0, maxval = 0; @@ -283,7 +283,7 @@ SLIgraphics::WritePGMFunction::execute( SLIInterpreter* i ) const long height = ( long ) h->get(); long maxval = ( long ) m->get(); - std::ostream* out = NULL; + std::ostream* out = nullptr; try { diff --git a/sli/slimath.cc b/sli/slimath.cc index 101b196522..4afce2445d 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -47,7 +47,7 @@ IntegerFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); DoubleDatum* op = dynamic_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op != NULL ) + if ( op != nullptr ) { Token res( new IntegerDatum( op->get() ) ); i->OStack.top().swap( res ); @@ -61,7 +61,7 @@ DoubleFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); IntegerDatum* op = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op != NULL ) + if ( op != nullptr ) { Token res( new DoubleDatum( op->get() ) ); @@ -269,7 +269,7 @@ Mod_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op1 == NULL || op2 == NULL ) + if ( op1 == nullptr || op2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -859,7 +859,7 @@ Inv_dFunction::execute( SLIInterpreter* i ) const DoubleDatum* op = static_cast< DoubleDatum* >( i->OStack.top().datum() ); - if ( op == NULL ) + if ( op == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -1119,7 +1119,7 @@ OrFunction::execute( SLIInterpreter* i ) const BoolDatum* op1 = static_cast< BoolDatum* >( i->OStack.pick( 1 ).datum() ); BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); op1->get() = ( op1->get() == true || op2->get() == true ); @@ -1261,7 +1261,7 @@ Gt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() > op2->get(); @@ -1278,7 +1278,7 @@ Gt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() > op2->get(); @@ -1296,7 +1296,7 @@ Gt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = *op1 > *op2; @@ -1323,7 +1323,7 @@ Lt_idFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() < op2->get(); @@ -1340,7 +1340,7 @@ Lt_diFunction::execute( SLIInterpreter* i ) const IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() < op2->get(); @@ -1358,7 +1358,7 @@ Lt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() < op2->get(); @@ -1375,7 +1375,7 @@ Lt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = op1->get() < op2->get(); @@ -1393,7 +1393,7 @@ Lt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != NULL && op2 != NULL ); + assert( op1 != nullptr && op2 != nullptr ); bool result = *op1 < *op2; @@ -1432,7 +1432,7 @@ UnitStep_iFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); IntegerDatum* x = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( x != NULL ); + assert( x != nullptr ); bool result = x->get() >= 0; @@ -1456,14 +1456,14 @@ UnitStep_daFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); TokenArray* a = dynamic_cast< TokenArray* >( i->OStack.pick( 0 ).datum() ); - assert( a != NULL ); + assert( a != nullptr ); bool result = true; for ( size_t j = 0; j < a->size(); ++j ) { DoubleDatum* x = static_cast< DoubleDatum* >( ( *a )[ j ].datum() ); - assert( x != NULL ); + assert( x != nullptr ); if ( x->get() < 0.0 ) { result = false; @@ -1490,14 +1490,14 @@ UnitStep_iaFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); TokenArray* a = dynamic_cast< TokenArray* >( i->OStack.pick( 0 ).datum() ); - assert( a != NULL ); + assert( a != nullptr ); bool result = true; for ( size_t j = 0; j < a->size(); ++j ) { IntegerDatum* x = static_cast< IntegerDatum* >( ( *a )[ j ].datum() ); - assert( x != NULL ); + assert( x != nullptr ); if ( x->get() < 0 ) { result = false; diff --git a/sli/sliregexp.cc b/sli/sliregexp.cc index d84a5d7b84..a30cd474cb 100644 --- a/sli/sliregexp.cc +++ b/sli/sliregexp.cc @@ -117,8 +117,8 @@ RegexpModule::RegcompFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); - assert( sd != NULL ); - assert( id != NULL ); + assert( sd != nullptr ); + assert( id != nullptr ); Regex* MyRegex = new Regex; @@ -147,8 +147,8 @@ RegexpModule::RegerrorFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); RegexDatum* rd = dynamic_cast< RegexDatum* >( i->OStack.pick( 1 ).datum() ); - assert( rd != NULL ); - assert( id != NULL ); + assert( rd != nullptr ); + assert( id != nullptr ); char* error_buffer = new char[ 256 ]; regerror( id->get(), rd->get()->get(), error_buffer, 256 ); @@ -178,16 +178,16 @@ RegexpModule::RegexecFunction::execute( SLIInterpreter* i ) const IntegerDatum* sized = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* eflagsd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( rd != NULL ); - assert( sd != NULL ); - assert( sized != NULL ); - assert( eflagsd != NULL ); + assert( rd != nullptr ); + assert( sd != nullptr ); + assert( sized != nullptr ); + assert( eflagsd != nullptr ); int size = sized->get(); regmatch_t* pm = new regmatch_t[ size ]; Regex* r = rd->get(); - assert( r != NULL ); + assert( r != nullptr ); rd->unlock(); int e = regexec( r->get(), sd->c_str(), size, pm, eflagsd->get() ); diff --git a/sli/slistack.cc b/sli/slistack.cc index 0b896e5051..d9a0f9e906 100644 --- a/sli/slistack.cc +++ b/sli/slistack.cc @@ -75,7 +75,7 @@ NpopFunction::execute( SLIInterpreter* i ) const } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != NULL ); + assert( id != nullptr ); size_t n = id->get(); if ( n < i->OStack.load() ) { @@ -166,7 +166,7 @@ IndexFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != NULL ); + assert( id != nullptr ); size_t pos = id->get(); if ( pos + 1 < i->OStack.load() ) @@ -201,7 +201,7 @@ CopyFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != NULL ); + assert( id != nullptr ); size_t n = id->get(); if ( n < i->OStack.load() ) { @@ -253,13 +253,13 @@ RollFunction::execute( SLIInterpreter* i ) const } IntegerDatum* idn = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idn == NULL ) + if ( idn == nullptr ) { throw ArgumentType( 1 ); } IntegerDatum* idk = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( idk == NULL ) + if ( idk == nullptr ) { throw ArgumentType( 0 ); } @@ -404,7 +404,7 @@ RestoreestackFunction::execute( SLIInterpreter* i ) const } ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); TokenArray ta = *ad; i->OStack.pop(); i->EStack = ta; @@ -434,7 +434,7 @@ RestoreostackFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != NULL ); + assert( ad != nullptr ); TokenArray ta = *ad; i->OStack = ta; } diff --git a/sli/slistartup.cc b/sli/slistartup.cc index 3121d45fc4..2ce4fe66cf 100644 --- a/sli/slistartup.cc +++ b/sli/slistartup.cc @@ -116,10 +116,10 @@ SLIStartup::GetenvFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != NULL ); + assert( sd != nullptr ); const char* s = ::getenv( sd->c_str() ); i->OStack.pop(); - if ( s != NULL ) + if ( s != nullptr ) { Token t( new StringDatum( s ) ); i->OStack.push_move( t ); diff --git a/sli/slitype.cc b/sli/slitype.cc index f2716c80c2..d8d2b32efc 100644 --- a/sli/slitype.cc +++ b/sli/slitype.cc @@ -59,7 +59,7 @@ SLIType::deletetypename( void ) void SLIType::setdefaultaction( SLIFunction& c ) { - if ( defaultaction == NULL ) + if ( defaultaction == nullptr ) { defaultaction = &c; } diff --git a/sli/slitype.h b/sli/slitype.h index 720ab079a4..d6e978d2d6 100644 --- a/sli/slitype.h +++ b/sli/slitype.h @@ -62,8 +62,8 @@ class SLIType public: SLIType( void ) : count( 0 ) - , name( NULL ) - , defaultaction( NULL ) + , name( nullptr ) + , defaultaction( nullptr ) { } ~SLIType() diff --git a/sli/slitypecheck.cc b/sli/slitypecheck.cc index ccaf3b6907..6d9657f682 100644 --- a/sli/slitypecheck.cc +++ b/sli/slitypecheck.cc @@ -56,7 +56,7 @@ TrieFunction::execute( SLIInterpreter* i ) const LiteralDatum* name = dynamic_cast< LiteralDatum* >( i->OStack.top().datum() ); - if ( name == NULL ) + if ( name == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -97,7 +97,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const TrieDatum* trie = dynamic_cast< TrieDatum* >( i->OStack.pick( 2 ).datum() ); - if ( trie == NULL ) + if ( trie == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -108,7 +108,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const // Construct a TypeArray from the TokenArray ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ad == NULL ) + if ( ad == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -127,7 +127,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const { LiteralDatum* nd = dynamic_cast< LiteralDatum* >( t->datum() ); - if ( nd == NULL ) + if ( nd == nullptr ) { std::ostringstream message; message << "In trie " << trie->getname() << ". " @@ -205,7 +205,7 @@ Cva_tFunction::execute( SLIInterpreter* i ) const i->OStack.pop(); TrieDatum* trie = dynamic_cast< TrieDatum* >( trietoken.datum() ); - assert( trie != NULL ); + assert( trie != nullptr ); Name triename( trie->getname() ); i->OStack.push( LiteralDatum( triename ) ); @@ -222,13 +222,13 @@ TrieInfoFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); OstreamDatum* osd = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( osd != 0 ); + assert( osd != nullptr ); Token trietoken; trietoken.move( i->OStack.top() ); TrieDatum* trie = dynamic_cast< TrieDatum* >( trietoken.datum() ); - assert( trie != NULL ); + assert( trie != nullptr ); trie->get().info( **osd ); i->OStack.pop( 2 ); @@ -305,12 +305,12 @@ Cvt_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.size() > 1 ); LiteralDatum* name = dynamic_cast< LiteralDatum* >( i->OStack.pick( 1 ).datum() ); - assert( name != NULL ); + assert( name != nullptr ); ArrayDatum* arr = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( arr != NULL ); + assert( arr != nullptr ); TrieDatum* trie = new TrieDatum( *name, *arr ); - assert( trie != NULL ); + assert( trie != nullptr ); Token tmp( trie ); i->OStack.pop(); i->OStack.push_move( tmp ); diff --git a/sli/tarrayobj.h b/sli/tarrayobj.h index 1930ff97bd..25dbba7efb 100644 --- a/sli/tarrayobj.h +++ b/sli/tarrayobj.h @@ -54,9 +54,9 @@ class TokenArrayObj public: TokenArrayObj( void ) - : p( NULL ) - , begin_of_free_storage( NULL ) - , end_of_free_storage( NULL ) + : p( nullptr ) + , begin_of_free_storage( nullptr ) + , end_of_free_storage( nullptr ) , alloc_block_size( ARRAY_ALLOC_SIZE ) , refs_( 1 ) {}; From b94a4b4b147baaacfdaed38c92b9910154913168 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 11:47:39 +0200 Subject: [PATCH 099/150] Remove redundant void arguments --- models/modelsmodule.h | 2 +- nestkernel/event.h | 2 +- sli/aggregatedatum.h | 2 +- sli/booldatum.h | 2 +- sli/dictstack.h | 6 +++--- sli/functiondatum.h | 4 ++-- sli/gnureadline.h | 2 +- sli/interpret.cc | 14 +++++++------- sli/name.h | 4 ++-- sli/oosupport.h | 6 +++--- sli/sliarray.cc | 4 ++-- sli/sligraphics.h | 4 ++-- sli/slimodule.cc | 2 +- sli/slimodule.h | 4 ++-- sli/sliregexp.cc | 6 +++--- sli/sliregexp.h | 8 ++++---- sli/slistartup.h | 2 +- sli/slitype.cc | 2 +- sli/slitype.h | 8 ++++---- sli/tarrayobj.h | 20 ++++++++++---------- 20 files changed, 52 insertions(+), 52 deletions(-) diff --git a/models/modelsmodule.h b/models/modelsmodule.h index 2249efcf20..945ee1076e 100644 --- a/models/modelsmodule.h +++ b/models/modelsmodule.h @@ -54,7 +54,7 @@ class ModelsModule : public SLIModule */ void init( SLIInterpreter* ); - const std::string name( void ) const; + const std::string name() const; }; diff --git a/nestkernel/event.h b/nestkernel/event.h index b00ff3f290..6da6842ca0 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -881,7 +881,7 @@ class SecondaryEvent : public Event */ template < typename T > size_t -number_of_uints_covered( void ) +number_of_uints_covered() { size_t num_uints = sizeof( T ) / sizeof( unsigned int ); if ( num_uints * sizeof( unsigned int ) < sizeof( T ) ) diff --git a/sli/aggregatedatum.h b/sli/aggregatedatum.h index d5b710ef53..ce535fda3a 100644 --- a/sli/aggregatedatum.h +++ b/sli/aggregatedatum.h @@ -63,7 +63,7 @@ class AggregateDatum : public TypedDatum< slt >, public C private: virtual Datum* - clone( void ) const + clone() const { return new AggregateDatum< C, slt >( *this ); } diff --git a/sli/booldatum.h b/sli/booldatum.h index 665ce451d8..896562d9d1 100644 --- a/sli/booldatum.h +++ b/sli/booldatum.h @@ -44,7 +44,7 @@ class BoolDatum : public GenericDatum< bool, &SLIInterpreter::Booltype > private: Datum* - clone( void ) const + clone() const override { return new BoolDatum( *this ); } diff --git a/sli/dictstack.h b/sli/dictstack.h index e3c5c6ad60..935d391ba6 100644 --- a/sli/dictstack.h +++ b/sli/dictstack.h @@ -338,7 +338,7 @@ class DictionaryStack bool where( const Name&, Token& ); - void pop( void ); + void pop(); // @@ -348,7 +348,7 @@ class DictionaryStack void push( const DictionaryDatum& ); void push( Token& ); - void clear( void ); + void clear(); void toArray( TokenArray& ) const; // // move is efficient for interaction with operand and execution @@ -360,7 +360,7 @@ class DictionaryStack // // number of dictionaries currently on the stack // - size_t size( void ) const; + size_t size() const; // diff --git a/sli/functiondatum.h b/sli/functiondatum.h index dcf6cc4ca8..0a1f3aafbc 100644 --- a/sli/functiondatum.h +++ b/sli/functiondatum.h @@ -56,7 +56,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > bool deprecation_warning_issued_; Datum* - clone( void ) const + clone() const { return new FunctionDatum( *this ); } @@ -146,7 +146,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > } const Name& - getname( void ) const + getname() const { return name; } diff --git a/sli/gnureadline.h b/sli/gnureadline.h index a2c651a289..fab7b98c0b 100644 --- a/sli/gnureadline.h +++ b/sli/gnureadline.h @@ -41,7 +41,7 @@ class GNUReadline : public SLIModule ~GNUReadline(); const std::string - name( void ) const + name() const override { return "GNUReadline"; } diff --git a/sli/interpret.cc b/sli/interpret.cc index df60ef95f6..f9c1076f7f 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -249,13 +249,13 @@ SLIInterpreter::initexternals( void ) ****************************************/ FunctionDatum* -SLIInterpreter::Ilookup( void ) const +SLIInterpreter::Ilookup() const { return new FunctionDatum( ilookup_name, &SLIInterpreter::ilookupfunction, "" ); } FunctionDatum* -SLIInterpreter::Iiterate( void ) const +SLIInterpreter::Iiterate() const { return new FunctionDatum( iiterate_name, &SLIInterpreter::iiteratefunction, "" ); } @@ -362,7 +362,7 @@ SLIInterpreter::basedef_move( Name const& n, Token& t ) DStack->basedef_move( n, t ); } -SLIInterpreter::SLIInterpreter( void ) +SLIInterpreter::SLIInterpreter() : debug_mode_( false ) , show_stack_( false ) , show_backtrace_( false ) @@ -722,7 +722,7 @@ SLIInterpreter::print_error( Token cmd ) } void -SLIInterpreter::raiseagain( void ) +SLIInterpreter::raiseagain() { assert( errordict != nullptr ); @@ -757,7 +757,7 @@ SLIInterpreter::verbosity( int level ) } int -SLIInterpreter::verbosity( void ) const +SLIInterpreter::verbosity() const { return verbositylevel; } @@ -928,7 +928,7 @@ SLIInterpreter::message( std::ostream& out, } Name -SLIInterpreter::getcurrentname( void ) const +SLIInterpreter::getcurrentname() const { FunctionDatum* func = dynamic_cast< FunctionDatum* >( EStack.top().datum() ); if ( func != nullptr ) @@ -951,7 +951,7 @@ SLIInterpreter::setcycleguard( Index c ) } void -SLIInterpreter::removecycleguard( void ) +SLIInterpreter::removecycleguard() { cycle_guard = false; } diff --git a/sli/name.h b/sli/name.h index 52655e7077..e8c77b32f8 100644 --- a/sli/name.h +++ b/sli/name.h @@ -79,13 +79,13 @@ class Name /** * Return string represented by Name. */ - const std::string& toString( void ) const; + const std::string& toString() const; /** * Return table index for Name object. */ handle_t - toIndex( void ) const + toIndex() const { return handle_; } diff --git a/sli/oosupport.h b/sli/oosupport.h index 8168e04c05..d5067a570f 100644 --- a/sli/oosupport.h +++ b/sli/oosupport.h @@ -41,13 +41,13 @@ class OOSupportModule : public SLIModule CallMemberFunction callmemberfunction; public: - OOSupportModule( void ) + OOSupportModule() { } void init( SLIInterpreter* ); - const std::string commandstring( void ) const; - const std::string name( void ) const; + const std::string commandstring() const; + const std::string name() const; }; diff --git a/sli/sliarray.cc b/sli/sliarray.cc index abfd2824bb..43eeb7201c 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -47,13 +47,13 @@ #include "tokenutils.h" const std::string -SLIArrayModule::commandstring( void ) const +SLIArrayModule::commandstring() const { return std::string( "(mathematica) run (arraylib) run" ); } const std::string -SLIArrayModule::name( void ) const +SLIArrayModule::name() const { return std::string( "SLI Array Module" ); } diff --git a/sli/sligraphics.h b/sli/sligraphics.h index 6b92d24a52..872625acc9 100644 --- a/sli/sligraphics.h +++ b/sli/sligraphics.h @@ -65,8 +65,8 @@ class SLIgraphics : public SLIModule } void init( SLIInterpreter* ); - const std::string name( void ) const; - const std::string commandstring( void ) const; + const std::string name() const; + const std::string commandstring() const; }; diff --git a/sli/slimodule.cc b/sli/slimodule.cc index 469afa257e..e96c540fb3 100644 --- a/sli/slimodule.cc +++ b/sli/slimodule.cc @@ -35,7 +35,7 @@ SLIModule::install( std::ostream&, SLIInterpreter* i ) } const std::string -SLIModule::commandstring( void ) const +SLIModule::commandstring() const { return std::string(); } diff --git a/sli/slimodule.h b/sli/slimodule.h index 4f60855863..54d6caaa01 100644 --- a/sli/slimodule.h +++ b/sli/slimodule.h @@ -51,12 +51,12 @@ class SLIModule /** * Return name of the module. */ - virtual const std::string name( void ) const = 0; + virtual const std::string name() const = 0; /** * Return sli command sequence to be executed for initialization. */ - virtual const std::string commandstring( void ) const; + virtual const std::string commandstring() const; /** * Print installation message via interpreter message command. diff --git a/sli/sliregexp.cc b/sli/sliregexp.cc index a30cd474cb..abf4ded1fe 100644 --- a/sli/sliregexp.cc +++ b/sli/sliregexp.cc @@ -48,7 +48,7 @@ Regex::~Regex() } regex_t* -Regex::get( void ) +Regex::get() { return &r; } @@ -95,13 +95,13 @@ RegexpModule::init( SLIInterpreter* i ) const std::string -RegexpModule::name( void ) const +RegexpModule::name() const { return std::string( "POSIX-Regexp" ); } const std::string -RegexpModule::commandstring( void ) const +RegexpModule::commandstring() const { return std::string( "(regexp) run" ); } diff --git a/sli/sliregexp.h b/sli/sliregexp.h index ba4b239e54..2a0df377c6 100644 --- a/sli/sliregexp.h +++ b/sli/sliregexp.h @@ -42,7 +42,7 @@ class Regex public: Regex(); ~Regex(); - regex_t* get( void ); + regex_t* get(); }; class RegexpModule : public SLIModule @@ -91,7 +91,7 @@ class RegexpModule : public SLIModule static SLIType RegexType; - RegexpModule( void ) + RegexpModule() : regexdict_name( "regexdict" ) , REG_NOTBOL_name( "REG_NOTBOL" ) , REG_NOTEOL_name( "REG_NOTEOL" ) @@ -117,8 +117,8 @@ class RegexpModule : public SLIModule ~RegexpModule(); void init( SLIInterpreter* ); - const std::string name( void ) const; - const std::string commandstring( void ) const; + const std::string name() const; + const std::string commandstring() const; }; #endif diff --git a/sli/slistartup.h b/sli/slistartup.h index 1bdd378134..3a46c239b1 100644 --- a/sli/slistartup.h +++ b/sli/slistartup.h @@ -148,7 +148,7 @@ class SLIStartup : public SLIModule void init( SLIInterpreter* ); const std::string - name( void ) const + name() const { return "SLIStartup"; } diff --git a/sli/slitype.cc b/sli/slitype.cc index d8d2b32efc..22835b1107 100644 --- a/sli/slitype.cc +++ b/sli/slitype.cc @@ -45,7 +45,7 @@ SLIType::settypename( const std::string& s ) } void -SLIType::deletetypename( void ) +SLIType::deletetypename() { assert( count > 0 ); if ( count == 1 ) diff --git a/sli/slitype.h b/sli/slitype.h index d6e978d2d6..b9a3523543 100644 --- a/sli/slitype.h +++ b/sli/slitype.h @@ -60,7 +60,7 @@ class SLIType SLIType( const SLIType& ); public: - SLIType( void ) + SLIType() : count( 0 ) , name( nullptr ) , defaultaction( nullptr ) @@ -71,10 +71,10 @@ class SLIType } void settypename( const std::string& s ); - void deletetypename( void ); + void deletetypename(); const Name& - gettypename( void ) const + gettypename() const { // assert( name !=NULL); return *name; @@ -84,7 +84,7 @@ class SLIType SLIFunction* - getaction( void ) const + getaction() const { // assert(defaultaction != NULL); // If this fails, we have created a datum before the types were initialised. diff --git a/sli/tarrayobj.h b/sli/tarrayobj.h index 25dbba7efb..c36730c4bc 100644 --- a/sli/tarrayobj.h +++ b/sli/tarrayobj.h @@ -53,7 +53,7 @@ class TokenArrayObj static size_t allocations; public: - TokenArrayObj( void ) + TokenArrayObj() : p( nullptr ) , begin_of_free_storage( nullptr ) , end_of_free_storage( nullptr ) @@ -78,13 +78,13 @@ class TokenArrayObj } size_t - size( void ) const + size() const { return ( size_t ) ( begin_of_free_storage - p ); } size_t - capacity( void ) const + capacity() const { return ( size_t ) ( end_of_free_storage - p ); } @@ -119,11 +119,11 @@ class TokenArrayObj // Memory allocation - bool shrink( void ); + bool shrink(); bool reserve( size_t ); unsigned int - references( void ) + references() { return refs_; } @@ -222,7 +222,7 @@ class TokenArrayObj } void - pop_back( void ) + pop_back() { ( --begin_of_free_storage )->clear(); } @@ -257,7 +257,7 @@ class TokenArrayObj void append_move( TokenArrayObj& ); - void clear( void ); + void clear(); const TokenArrayObj& operator=( const TokenArrayObj& ); @@ -265,7 +265,7 @@ class TokenArrayObj bool operator==( const TokenArrayObj& ) const; bool - empty( void ) const + empty() const { return size() == 0; } @@ -273,12 +273,12 @@ class TokenArrayObj void info( std::ostream& ) const; static size_t - getallocations( void ) + getallocations() { return allocations; } - bool valid( void ) const; // check integrity + bool valid() const; // check integrity }; std::ostream& operator<<( std::ostream&, const TokenArrayObj& ); From 17054296ab68ed4ad6e77062419b2939036376b5 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 12:01:53 +0200 Subject: [PATCH 100/150] Added missing overrides --- models/aeif_cond_alpha_multisynapse.h | 2 +- models/aeif_cond_beta_multisynapse.h | 2 +- models/aeif_psc_alpha.h | 26 ++--- models/bernoulli_synapse.h | 2 +- models/gif_cond_exp.h | 26 ++--- models/gif_psc_exp.h | 24 ++-- models/iaf_chxk_2008.h | 28 ++--- models/iaf_psc_alpha_multisynapse.h | 24 ++-- models/izhikevich.h | 24 ++-- models/modelsmodule.h | 6 +- models/parrot_neuron.h | 20 ++-- models/quantal_stp_synapse.h | 2 +- models/spike_recorder.h | 22 ++-- models/stdp_nn_symm_synapse.h | 2 +- models/stdp_triplet_synapse.h | 2 +- models/tsodyks2_synapse.h | 2 +- models/tsodyks_synapse.h | 2 +- models/weight_recorder.h | 22 ++-- nestkernel/connection.h | 12 +- nestkernel/connection_manager.h | 2 +- nestkernel/device_node.h | 4 +- nestkernel/event.h | 2 +- nestkernel/exceptions.h | 6 +- nestkernel/growth_curve_factory.h | 2 +- nestkernel/model_manager.h | 10 +- nestkernel/modelrange_manager.h | 8 +- nestkernel/mpi_manager.h | 8 +- nestkernel/music_manager.h | 8 +- nestkernel/node_manager.h | 10 +- nestkernel/pseudo_recording_device.h | 2 +- nestkernel/random_manager.h | 10 +- nestkernel/simulation_manager.h | 8 +- nestkernel/sp_manager.h | 10 +- nestkernel/vp_manager.h | 8 +- sli/functiondatum.h | 14 +-- sli/oosupport.h | 8 +- sli/sliarray.h | 4 +- sli/slidata.h | 116 +++++++++--------- sli/slidict.h | 46 ++++---- sli/sliexceptions.h | 66 +++++------ sli/sligraphics.h | 10 +- sli/slimath.h | 162 +++++++++++++------------- sli/sliregexp.h | 14 +-- sli/slistack.h | 34 +++--- sli/slistartup.h | 8 +- sli/slitypecheck.h | 12 +- 46 files changed, 421 insertions(+), 421 deletions(-) diff --git a/models/aeif_cond_alpha_multisynapse.h b/models/aeif_cond_alpha_multisynapse.h index e296b6e518..f9db7b5ece 100644 --- a/models/aeif_cond_alpha_multisynapse.h +++ b/models/aeif_cond_alpha_multisynapse.h @@ -179,7 +179,7 @@ class aeif_cond_alpha_multisynapse : public ArchivingNode public: aeif_cond_alpha_multisynapse(); aeif_cond_alpha_multisynapse( const aeif_cond_alpha_multisynapse& ); - virtual ~aeif_cond_alpha_multisynapse(); + ~aeif_cond_alpha_multisynapse() override; friend int aeif_cond_alpha_multisynapse_dynamics( double, const double*, double*, void* ); diff --git a/models/aeif_cond_beta_multisynapse.h b/models/aeif_cond_beta_multisynapse.h index 5b132d57a0..a43d1f16cb 100644 --- a/models/aeif_cond_beta_multisynapse.h +++ b/models/aeif_cond_beta_multisynapse.h @@ -182,7 +182,7 @@ class aeif_cond_beta_multisynapse : public ArchivingNode public: aeif_cond_beta_multisynapse(); aeif_cond_beta_multisynapse( const aeif_cond_beta_multisynapse& ); - virtual ~aeif_cond_beta_multisynapse(); + ~aeif_cond_beta_multisynapse() override; friend int aeif_cond_beta_multisynapse_dynamics( double, const double*, double*, void* ); diff --git a/models/aeif_psc_alpha.h b/models/aeif_psc_alpha.h index 31eac76263..86dcba00f4 100644 --- a/models/aeif_psc_alpha.h +++ b/models/aeif_psc_alpha.h @@ -179,7 +179,7 @@ class aeif_psc_alpha : public ArchivingNode public: aeif_psc_alpha(); aeif_psc_alpha( const aeif_psc_alpha& ); - ~aeif_psc_alpha(); + ~aeif_psc_alpha() override; /** * Import sets of overloaded virtual functions. @@ -189,23 +189,23 @@ class aeif_psc_alpha : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/bernoulli_synapse.h b/models/bernoulli_synapse.h index 233cb90e9e..3a0ff0c91f 100644 --- a/models/bernoulli_synapse.h +++ b/models/bernoulli_synapse.h @@ -130,7 +130,7 @@ class bernoulli_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/gif_cond_exp.h b/models/gif_cond_exp.h index 59d4b3464e..e02f45da2d 100644 --- a/models/gif_cond_exp.h +++ b/models/gif_cond_exp.h @@ -221,7 +221,7 @@ class gif_cond_exp : public ArchivingNode public: gif_cond_exp(); gif_cond_exp( const gif_cond_exp& ); - ~gif_cond_exp(); + ~gif_cond_exp() override; /** * Import sets of overloaded virtual functions. @@ -231,25 +231,25 @@ class gif_cond_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // make dynamics function quasi-member friend int gif_cond_exp_dynamics( double, const double*, double*, void* ); diff --git a/models/gif_psc_exp.h b/models/gif_psc_exp.h index f8abf38b3e..c8e857a4f9 100644 --- a/models/gif_psc_exp.h +++ b/models/gif_psc_exp.h @@ -214,24 +214,24 @@ class gif_psc_exp : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class RecordablesMap< gif_psc_exp >; diff --git a/models/iaf_chxk_2008.h b/models/iaf_chxk_2008.h index c6e9e27641..a022c9cbb4 100644 --- a/models/iaf_chxk_2008.h +++ b/models/iaf_chxk_2008.h @@ -148,7 +148,7 @@ class iaf_chxk_2008 : public ArchivingNode public: iaf_chxk_2008(); iaf_chxk_2008( const iaf_chxk_2008& ); - ~iaf_chxk_2008(); + ~iaf_chxk_2008() override; /** * Import sets of overloaded virtual functions. @@ -158,29 +158,29 @@ class iaf_chxk_2008 : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; bool - is_off_grid() const + is_off_grid() const override { return true; } - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); - void update( Time const&, const long, const long ); + void init_buffers_() override; + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; // END Boilerplate function declarations ---------------------------- diff --git a/models/iaf_psc_alpha_multisynapse.h b/models/iaf_psc_alpha_multisynapse.h index 966ec3a111..2aa1e482ab 100644 --- a/models/iaf_psc_alpha_multisynapse.h +++ b/models/iaf_psc_alpha_multisynapse.h @@ -98,24 +98,24 @@ class iaf_psc_alpha_multisynapse : public ArchivingNode using Node::handle; using Node::handles_test_event; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); - void handle( DataLoggingRequest& ); + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; + void handle( DataLoggingRequest& ) override; - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); - port handles_test_event( DataLoggingRequest&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; + port handles_test_event( DataLoggingRequest&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // The next two classes need to be friends to access the State_ class/member friend class DynamicRecordablesMap< iaf_psc_alpha_multisynapse >; diff --git a/models/izhikevich.h b/models/izhikevich.h index 23d861fd2f..a95bd3fba4 100644 --- a/models/izhikevich.h +++ b/models/izhikevich.h @@ -139,27 +139,27 @@ class izhikevich : public ArchivingNode using Node::handle; using Node::handles_test_event; - void handle( DataLoggingRequest& ); - void handle( SpikeEvent& ); - void handle( CurrentEvent& ); + void handle( DataLoggingRequest& ) override; + void handle( SpikeEvent& ) override; + void handle( CurrentEvent& ) override; - port handles_test_event( DataLoggingRequest&, rport ); - port handles_test_event( SpikeEvent&, rport ); - port handles_test_event( CurrentEvent&, rport ); + port handles_test_event( DataLoggingRequest&, rport ) override; + port handles_test_event( SpikeEvent&, rport ) override; + port handles_test_event( CurrentEvent&, rport ) override; - port send_test_event( Node&, rport, synindex, bool ); + port send_test_event( Node&, rport, synindex, bool ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: friend class RecordablesMap< izhikevich >; friend class UniversalDataLogger< izhikevich >; - void init_buffers_(); - void pre_run_hook(); + void init_buffers_() override; + void pre_run_hook() override; - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; // ---------------------------------------------------------------- diff --git a/models/modelsmodule.h b/models/modelsmodule.h index 945ee1076e..e7f9aea6a5 100644 --- a/models/modelsmodule.h +++ b/models/modelsmodule.h @@ -46,15 +46,15 @@ class ModelsModule : public SLIModule { public: ModelsModule(); - ~ModelsModule(); + ~ModelsModule() override; /** * Initialize module by registering models with the network. * @param SLIInterpreter* SLI interpreter */ - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; - const std::string name() const; + const std::string name() const override; }; diff --git a/models/parrot_neuron.h b/models/parrot_neuron.h index 4b0350603c..617c812244 100644 --- a/models/parrot_neuron.h +++ b/models/parrot_neuron.h @@ -91,24 +91,24 @@ class parrot_neuron : public ArchivingNode using Node::receives_signal; using Node::sends_signal; - port send_test_event( Node&, rport, synindex, bool ); - SignalType sends_signal() const; - SignalType receives_signal() const; + port send_test_event( Node&, rport, synindex, bool ) override; + SignalType sends_signal() const override; + SignalType receives_signal() const override; - void handle( SpikeEvent& ); - port handles_test_event( SpikeEvent&, rport ); + void handle( SpikeEvent& ) override; + port handles_test_event( SpikeEvent&, rport ) override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void init_buffers_(); + void init_buffers_() override; void - pre_run_hook() + pre_run_hook() override { } // no variables - void update( Time const&, const long, const long ); + void update( Time const&, const long, const long ) override; /** Buffers and accumulates the number of incoming spikes per time step; diff --git a/models/quantal_stp_synapse.h b/models/quantal_stp_synapse.h index 634e5f6578..a079601512 100644 --- a/models/quantal_stp_synapse.h +++ b/models/quantal_stp_synapse.h @@ -154,7 +154,7 @@ class quantal_stp_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/spike_recorder.h b/models/spike_recorder.h index c3ed94e3f9..f29d8ce6fb 100644 --- a/models/spike_recorder.h +++ b/models/spike_recorder.h @@ -86,19 +86,19 @@ class spike_recorder : public RecordingDevice spike_recorder( const spike_recorder& ); bool - has_proxies() const + has_proxies() const override { return false; } bool - local_receiver() const + local_receiver() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -112,19 +112,19 @@ class spike_recorder : public RecordingDevice using Node::handles_test_event; using Node::receives_signal; - void handle( SpikeEvent& ); + void handle( SpikeEvent& ) override; - port handles_test_event( SpikeEvent&, rport ); + port handles_test_event( SpikeEvent&, rport ) override; - Type get_type() const; - SignalType receives_signal() const; + Type get_type() const override; + SignalType receives_signal() const override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void pre_run_hook(); - void update( Time const&, const long, const long ); + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; }; inline port diff --git a/models/stdp_nn_symm_synapse.h b/models/stdp_nn_symm_synapse.h index a9d40796b2..929faa1551 100644 --- a/models/stdp_nn_symm_synapse.h +++ b/models/stdp_nn_symm_synapse.h @@ -175,7 +175,7 @@ class stdp_nn_symm_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/stdp_triplet_synapse.h b/models/stdp_triplet_synapse.h index 35fb352cf2..8551c059f6 100644 --- a/models/stdp_triplet_synapse.h +++ b/models/stdp_triplet_synapse.h @@ -174,7 +174,7 @@ class stdp_triplet_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/tsodyks2_synapse.h b/models/tsodyks2_synapse.h index 171745be74..4cda0ada97 100644 --- a/models/tsodyks2_synapse.h +++ b/models/tsodyks2_synapse.h @@ -172,7 +172,7 @@ class tsodyks2_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/tsodyks_synapse.h b/models/tsodyks_synapse.h index 97eb58e1af..f92dd058f3 100644 --- a/models/tsodyks_synapse.h +++ b/models/tsodyks_synapse.h @@ -191,7 +191,7 @@ class tsodyks_synapse : public Connection< targetidentifierT > // Return values from functions are ignored. using ConnTestDummyNodeBase::handles_test_event; port - handles_test_event( SpikeEvent&, rport ) + handles_test_event( SpikeEvent&, rport ) override { return invalid_port; } diff --git a/models/weight_recorder.h b/models/weight_recorder.h index ebfb8f920b..2006942b76 100644 --- a/models/weight_recorder.h +++ b/models/weight_recorder.h @@ -89,19 +89,19 @@ class weight_recorder : public RecordingDevice weight_recorder( const weight_recorder& ); bool - has_proxies() const + has_proxies() const override { return false; } bool - local_receiver() const + local_receiver() const override { return true; } Name - get_element_type() const + get_element_type() const override { return names::recorder; } @@ -115,19 +115,19 @@ class weight_recorder : public RecordingDevice using Node::handles_test_event; using Node::receives_signal; - void handle( WeightRecorderEvent& ); + void handle( WeightRecorderEvent& ) override; - port handles_test_event( WeightRecorderEvent&, rport ); + port handles_test_event( WeightRecorderEvent&, rport ) override; - Type get_type() const; - SignalType receives_signal() const; + Type get_type() const override; + SignalType receives_signal() const override; - void get_status( DictionaryDatum& ) const; - void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) const override; + void set_status( const DictionaryDatum& ) override; private: - void pre_run_hook(); - void update( Time const&, const long, const long ); + void pre_run_hook() override; + void update( Time const&, const long, const long ) override; struct Parameters_ { diff --git a/nestkernel/connection.h b/nestkernel/connection.h index 30faecbe9d..e8adb84c84 100644 --- a/nestkernel/connection.h +++ b/nestkernel/connection.h @@ -71,27 +71,27 @@ class ConnectorModel; class ConnTestDummyNodeBase : public Node { void - pre_run_hook() + pre_run_hook() override { } void - update( const nest::Time&, long, long ) + update( const nest::Time&, long, long ) override { } void - set_status( const DictionaryDatum& ) + set_status( const DictionaryDatum& ) override { } void - get_status( DictionaryDatum& ) const + get_status( DictionaryDatum& ) const override { } void - init_state_() + init_state_() override { } void - init_buffers_() + init_buffers_() override { } }; diff --git a/nestkernel/connection_manager.h b/nestkernel/connection_manager.h index 5808b5f8ca..57b6604bf4 100644 --- a/nestkernel/connection_manager.h +++ b/nestkernel/connection_manager.h @@ -76,7 +76,7 @@ class ConnectionManager : public ManagerInterface }; ConnectionManager(); - virtual ~ConnectionManager(); + ~ConnectionManager() override; virtual void initialize() override; virtual void finalize() override; diff --git a/nestkernel/device_node.h b/nestkernel/device_node.h index 9588a6ff9f..8a82b13c09 100644 --- a/nestkernel/device_node.h +++ b/nestkernel/device_node.h @@ -48,8 +48,8 @@ class DeviceNode : public Node { } - void set_local_device_id( const index ldid ); - index get_local_device_id() const; + void set_local_device_id( const index ldid ) override; + index get_local_device_id() const override; protected: index local_device_id_; diff --git a/nestkernel/event.h b/nestkernel/event.h index 6da6842ca0..24882a0256 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -857,7 +857,7 @@ class SecondaryEvent : public Event { public: - virtual SecondaryEvent* clone() const = 0; + SecondaryEvent* clone() const override = 0; virtual void add_syn_id( const synindex synid ) = 0; diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index 84f3a91f92..a824440ee0 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -73,12 +73,12 @@ class KernelException : public SLIException { } - virtual ~KernelException() throw() + ~KernelException() throw() override { } - virtual std::string - message() const + std::string + message() const override { return std::string(); } diff --git a/nestkernel/growth_curve_factory.h b/nestkernel/growth_curve_factory.h index 767bd57d63..916d071173 100644 --- a/nestkernel/growth_curve_factory.h +++ b/nestkernel/growth_curve_factory.h @@ -59,7 +59,7 @@ class GrowthCurveFactory : public GenericGrowthCurveFactory public: GrowthCurve* - create() const + create() const override { return new GrowthCurveType(); } diff --git a/nestkernel/model_manager.h b/nestkernel/model_manager.h index e5e173517d..f09c165487 100644 --- a/nestkernel/model_manager.h +++ b/nestkernel/model_manager.h @@ -48,11 +48,11 @@ class ModelManager : public ManagerInterface ModelManager(); ~ModelManager(); - virtual void initialize() override; - virtual void finalize() override; - virtual void change_number_of_threads() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void change_number_of_threads() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Resize the structures for the Connector objects if necessary. diff --git a/nestkernel/modelrange_manager.h b/nestkernel/modelrange_manager.h index 0a6b4b0f57..75788312cb 100644 --- a/nestkernel/modelrange_manager.h +++ b/nestkernel/modelrange_manager.h @@ -45,10 +45,10 @@ class ModelRangeManager : public ManagerInterface { } - virtual void initialize() override; - virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Assign a range of node IDs for the given model diff --git a/nestkernel/mpi_manager.h b/nestkernel/mpi_manager.h index 70723c4e67..6b03521772 100644 --- a/nestkernel/mpi_manager.h +++ b/nestkernel/mpi_manager.h @@ -65,10 +65,10 @@ class MPIManager : public ManagerInterface { } - virtual void initialize() override; - virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; void init_mpi( int* argc, char** argv[] ); #ifdef HAVE_MPI diff --git a/nestkernel/music_manager.h b/nestkernel/music_manager.h index a2ba7097d2..a76d29d517 100644 --- a/nestkernel/music_manager.h +++ b/nestkernel/music_manager.h @@ -52,10 +52,10 @@ namespace nest class MUSICManager : public ManagerInterface { public: - virtual void initialize() override; - virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; MUSICManager(); diff --git a/nestkernel/node_manager.h b/nestkernel/node_manager.h index 034c41e642..c8d6415021 100644 --- a/nestkernel/node_manager.h +++ b/nestkernel/node_manager.h @@ -52,11 +52,11 @@ class NodeManager : public ManagerInterface NodeManager(); ~NodeManager(); - virtual void initialize() override; - virtual void finalize() override; - virtual void change_number_of_threads() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void change_number_of_threads() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Get properties of a node. The specified node must exist. diff --git a/nestkernel/pseudo_recording_device.h b/nestkernel/pseudo_recording_device.h index 725bb9fa45..7b24d82770 100644 --- a/nestkernel/pseudo_recording_device.h +++ b/nestkernel/pseudo_recording_device.h @@ -81,7 +81,7 @@ class PseudoRecordingDevice : public Device public: PseudoRecordingDevice(); PseudoRecordingDevice( const PseudoRecordingDevice& ); - virtual ~PseudoRecordingDevice() + ~PseudoRecordingDevice() override { } diff --git a/nestkernel/random_manager.h b/nestkernel/random_manager.h index 53a8cd9834..4fbf987d0d 100644 --- a/nestkernel/random_manager.h +++ b/nestkernel/random_manager.h @@ -56,11 +56,11 @@ class RandomManager : public ManagerInterface /** * Register available RNG types, set default RNG type and create RNGs. */ - virtual void initialize() override; - virtual void finalize() override; - virtual void change_number_of_threads() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void change_number_of_threads() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Get rank-synchronized random number generator. diff --git a/nestkernel/simulation_manager.h b/nestkernel/simulation_manager.h index 341724c071..fc3d1406a1 100644 --- a/nestkernel/simulation_manager.h +++ b/nestkernel/simulation_manager.h @@ -49,10 +49,10 @@ class SimulationManager : public ManagerInterface public: SimulationManager(); - virtual void initialize() override; - virtual void finalize() override; - virtual void set_status( const DictionaryDatum& ) override; - virtual void get_status( DictionaryDatum& ) override; + void initialize() override; + void finalize() override; + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** check for errors in time before run diff --git a/nestkernel/sp_manager.h b/nestkernel/sp_manager.h index 3ec4f77e9d..6f5a17fcd1 100644 --- a/nestkernel/sp_manager.h +++ b/nestkernel/sp_manager.h @@ -64,13 +64,13 @@ class SPManager : public ManagerInterface public: SPManager(); - virtual ~SPManager(); + ~SPManager() override; - virtual void initialize(); - virtual void finalize(); + void initialize() override; + void finalize() override; - virtual void get_status( DictionaryDatum& ); - virtual void set_status( const DictionaryDatum& ); + void get_status( DictionaryDatum& ) override; + void set_status( const DictionaryDatum& ) override; /** * Create a new Growth Curve object using the GrowthCurve Factory diff --git a/nestkernel/vp_manager.h b/nestkernel/vp_manager.h index 381e8d767d..2b3e0c69f0 100644 --- a/nestkernel/vp_manager.h +++ b/nestkernel/vp_manager.h @@ -56,11 +56,11 @@ class VPManager : public ManagerInterface { } - virtual void initialize(); - virtual void finalize(); + void initialize() override; + void finalize() override; - virtual void set_status( const DictionaryDatum& ); - virtual void get_status( DictionaryDatum& ); + void set_status( const DictionaryDatum& ) override; + void get_status( DictionaryDatum& ) override; /** * Gets ID of local thread. diff --git a/sli/functiondatum.h b/sli/functiondatum.h index 0a1f3aafbc..722e207b06 100644 --- a/sli/functiondatum.h +++ b/sli/functiondatum.h @@ -56,13 +56,13 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > bool deprecation_warning_issued_; Datum* - clone() const + clone() const override { return new FunctionDatum( *this ); } Datum* - get_ptr() + get_ptr() override { Datum::addReference(); return this; @@ -101,7 +101,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > } void - execute( SLIInterpreter* i ) + execute( SLIInterpreter* i ) override { if ( not( deprecation_warning_issued_ or deprecation_info_.empty() ) ) { @@ -115,26 +115,26 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > } void - print( std::ostream& o ) const + print( std::ostream& o ) const override { o << '-' << name << '-'; } void - pprint( std::ostream& o ) const + pprint( std::ostream& o ) const override { print( o ); } void - info( std::ostream& out ) const + info( std::ostream& out ) const override { out << "FunctionDatum::info\n"; out << "name = " << name << std::endl; } bool - equals( Datum const* dat ) const + equals( Datum const* dat ) const override { const FunctionDatum* fd = dynamic_cast< FunctionDatum* >( const_cast< Datum* >( dat ) ); if ( fd == nullptr ) diff --git a/sli/oosupport.h b/sli/oosupport.h index d5067a570f..6e1bb050e9 100644 --- a/sli/oosupport.h +++ b/sli/oosupport.h @@ -35,7 +35,7 @@ class OOSupportModule : public SLIModule class CallMemberFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; CallMemberFunction callmemberfunction; @@ -45,9 +45,9 @@ class OOSupportModule : public SLIModule { } - void init( SLIInterpreter* ); - const std::string commandstring() const; - const std::string name() const; + void init( SLIInterpreter* ) override; + const std::string commandstring() const override; + const std::string name() const override; }; diff --git a/sli/sliarray.h b/sli/sliarray.h index b553341e1e..8e62593eb6 100644 --- a/sli/sliarray.h +++ b/sli/sliarray.h @@ -495,13 +495,13 @@ class SLIArrayModule : public SLIModule class Ones_ivFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ArangeFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; /** diff --git a/sli/slidata.h b/sli/slidata.h index 5fc2e21069..20aec37307 100644 --- a/sli/slidata.h +++ b/sli/slidata.h @@ -43,7 +43,7 @@ class Get_aFunction : public SLIFunction Get_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_a_aFunction : public SLIFunction @@ -52,7 +52,7 @@ class Get_a_aFunction : public SLIFunction Get_a_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Allocations_aFunction : public SLIFunction @@ -61,7 +61,7 @@ class Allocations_aFunction : public SLIFunction Allocations_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_pFunction : public SLIFunction @@ -70,7 +70,7 @@ class Get_pFunction : public SLIFunction Get_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_lpFunction : public SLIFunction @@ -79,7 +79,7 @@ class Get_lpFunction : public SLIFunction Get_lpFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Append_aFunction : public SLIFunction @@ -88,7 +88,7 @@ class Append_aFunction : public SLIFunction Append_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Append_pFunction : public SLIFunction @@ -97,7 +97,7 @@ class Append_pFunction : public SLIFunction Append_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Append_sFunction : public SLIFunction @@ -106,7 +106,7 @@ class Append_sFunction : public SLIFunction Append_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Prepend_aFunction : public SLIFunction @@ -115,7 +115,7 @@ class Prepend_aFunction : public SLIFunction Prepend_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Prepend_pFunction : public SLIFunction @@ -124,7 +124,7 @@ class Prepend_pFunction : public SLIFunction Prepend_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Prepend_sFunction : public SLIFunction @@ -133,7 +133,7 @@ class Prepend_sFunction : public SLIFunction Prepend_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Join_sFunction : public SLIFunction @@ -142,7 +142,7 @@ class Join_sFunction : public SLIFunction Join_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Join_aFunction : public SLIFunction @@ -151,7 +151,7 @@ class Join_aFunction : public SLIFunction Join_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Join_pFunction : public SLIFunction @@ -160,7 +160,7 @@ class Join_pFunction : public SLIFunction Join_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Insert_sFunction : public SLIFunction @@ -169,7 +169,7 @@ class Insert_sFunction : public SLIFunction Insert_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Insert_aFunction : public SLIFunction @@ -178,7 +178,7 @@ class Insert_aFunction : public SLIFunction Insert_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class InsertElement_sFunction : public SLIFunction @@ -187,7 +187,7 @@ class InsertElement_sFunction : public SLIFunction InsertElement_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class InsertElement_aFunction : public SLIFunction @@ -196,7 +196,7 @@ class InsertElement_aFunction : public SLIFunction InsertElement_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Replace_sFunction : public SLIFunction @@ -205,7 +205,7 @@ class Replace_sFunction : public SLIFunction Replace_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Replace_aFunction : public SLIFunction @@ -214,7 +214,7 @@ class Replace_aFunction : public SLIFunction Replace_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Erase_sFunction : public SLIFunction @@ -223,7 +223,7 @@ class Erase_sFunction : public SLIFunction Erase_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Erase_aFunction : public SLIFunction @@ -232,7 +232,7 @@ class Erase_aFunction : public SLIFunction Erase_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Erase_pFunction : public SLIFunction @@ -241,7 +241,7 @@ class Erase_pFunction : public SLIFunction Erase_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -251,7 +251,7 @@ class Length_sFunction : public SLIFunction Length_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_aFunction : public SLIFunction @@ -260,7 +260,7 @@ class Length_aFunction : public SLIFunction Length_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_pFunction : public SLIFunction @@ -269,7 +269,7 @@ class Length_pFunction : public SLIFunction Length_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_lpFunction : public SLIFunction @@ -278,7 +278,7 @@ class Length_lpFunction : public SLIFunction Length_lpFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Capacity_aFunction : public SLIFunction @@ -287,7 +287,7 @@ class Capacity_aFunction : public SLIFunction Capacity_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Size_aFunction : public SLIFunction @@ -296,7 +296,7 @@ class Size_aFunction : public SLIFunction Size_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Reserve_aFunction : public SLIFunction @@ -305,7 +305,7 @@ class Reserve_aFunction : public SLIFunction Reserve_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Resize_aFunction : public SLIFunction @@ -314,7 +314,7 @@ class Resize_aFunction : public SLIFunction Resize_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Empty_aFunction : public SLIFunction @@ -323,7 +323,7 @@ class Empty_aFunction : public SLIFunction Empty_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class References_aFunction : public SLIFunction @@ -332,7 +332,7 @@ class References_aFunction : public SLIFunction References_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Shrink_aFunction : public SLIFunction @@ -342,7 +342,7 @@ class Shrink_aFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Capacity_sFunction : public SLIFunction @@ -351,7 +351,7 @@ class Capacity_sFunction : public SLIFunction Capacity_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Size_sFunction : public SLIFunction @@ -360,7 +360,7 @@ class Size_sFunction : public SLIFunction Size_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Reserve_sFunction : public SLIFunction @@ -369,7 +369,7 @@ class Reserve_sFunction : public SLIFunction Reserve_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Resize_sFunction : public SLIFunction @@ -378,7 +378,7 @@ class Resize_sFunction : public SLIFunction Resize_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Empty_sFunction : public SLIFunction @@ -387,7 +387,7 @@ class Empty_sFunction : public SLIFunction Empty_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Getinterval_sFunction : public SLIFunction @@ -396,7 +396,7 @@ class Getinterval_sFunction : public SLIFunction Getinterval_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Getinterval_aFunction : public SLIFunction @@ -405,7 +405,7 @@ class Getinterval_aFunction : public SLIFunction Getinterval_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvx_aFunction : public SLIFunction @@ -414,7 +414,7 @@ class Cvx_aFunction : public SLIFunction Cvx_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvlit_nFunction : public SLIFunction @@ -423,7 +423,7 @@ class Cvlit_nFunction : public SLIFunction Cvlit_nFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvlit_pFunction : public SLIFunction @@ -432,7 +432,7 @@ class Cvlit_pFunction : public SLIFunction Cvlit_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvlp_pFunction : public SLIFunction @@ -441,7 +441,7 @@ class Cvlp_pFunction : public SLIFunction Cvlp_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvn_sFunction : public SLIFunction @@ -450,7 +450,7 @@ class Cvn_sFunction : public SLIFunction Cvn_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvn_lFunction : public SLIFunction @@ -459,7 +459,7 @@ class Cvn_lFunction : public SLIFunction Cvn_lFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //--------------------------------------------------------------------------------- @@ -494,7 +494,7 @@ class Cvi_sFunction : public SLIFunction Cvi_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //--------------------------------------------------------------------------------- @@ -530,7 +530,7 @@ class Cvd_sFunction : public SLIFunction Cvd_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Get_sFunction : public SLIFunction @@ -539,7 +539,7 @@ class Get_sFunction : public SLIFunction Get_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_sFunction : public SLIFunction @@ -548,7 +548,7 @@ class Put_sFunction : public SLIFunction Put_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_aFunction : public SLIFunction @@ -557,7 +557,7 @@ class Put_aFunction : public SLIFunction Put_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_pFunction : public SLIFunction @@ -566,7 +566,7 @@ class Put_pFunction : public SLIFunction Put_pFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Put_lpFunction : public SLIFunction @@ -575,7 +575,7 @@ class Put_lpFunction : public SLIFunction Put_lpFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Search_sFunction : public SLIFunction @@ -584,7 +584,7 @@ class Search_sFunction : public SLIFunction Search_sFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Search_aFunction : public SLIFunction @@ -593,7 +593,7 @@ class Search_aFunction : public SLIFunction Search_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; // This function is not implemented @@ -612,7 +612,7 @@ class IrepeatanyFunction : public SLIFunction IrepeatanyFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RepeatanyFunction : public SLIFunction @@ -621,7 +621,7 @@ class RepeatanyFunction : public SLIFunction RepeatanyFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; diff --git a/sli/slidict.h b/sli/slidict.h index dcb3bbabe7..09e4fc456c 100644 --- a/sli/slidict.h +++ b/sli/slidict.h @@ -45,7 +45,7 @@ class DictFunction : public SLIFunction DictFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictputFunction : public SLIFunction @@ -54,7 +54,7 @@ class DictputFunction : public SLIFunction DictputFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictgetFunction : public SLIFunction @@ -63,7 +63,7 @@ class DictgetFunction : public SLIFunction DictgetFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictbeginFunction : public SLIFunction @@ -72,7 +72,7 @@ class DictbeginFunction : public SLIFunction DictbeginFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictendFunction : public SLIFunction @@ -81,7 +81,7 @@ class DictendFunction : public SLIFunction DictendFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; // MH fx 2010-09-28 @@ -101,7 +101,7 @@ class DictinfoFunction : public SLIFunction DictinfoFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DicttopinfoFunction : public SLIFunction @@ -110,7 +110,7 @@ class DicttopinfoFunction : public SLIFunction DicttopinfoFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class WhoFunction : public SLIFunction @@ -119,7 +119,7 @@ class WhoFunction : public SLIFunction WhoFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictconstructFunction : public SLIFunction @@ -128,7 +128,7 @@ class DictconstructFunction : public SLIFunction DictconstructFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DictstackFunction : public SLIFunction @@ -137,7 +137,7 @@ class DictstackFunction : public SLIFunction DictstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CurrentdictFunction : public SLIFunction @@ -146,7 +146,7 @@ class CurrentdictFunction : public SLIFunction CurrentdictFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CountdictstackFunction : public SLIFunction @@ -155,7 +155,7 @@ class CountdictstackFunction : public SLIFunction CountdictstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CleardictstackFunction : public SLIFunction @@ -164,7 +164,7 @@ class CleardictstackFunction : public SLIFunction CleardictstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Length_dFunction : public SLIFunction @@ -173,7 +173,7 @@ class Length_dFunction : public SLIFunction Length_dFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Empty_DFunction : public SLIFunction @@ -182,7 +182,7 @@ class Empty_DFunction : public SLIFunction Empty_DFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CleardictFunction : public SLIFunction @@ -191,7 +191,7 @@ class CleardictFunction : public SLIFunction CleardictFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ClonedictFunction : public SLIFunction @@ -200,7 +200,7 @@ class ClonedictFunction : public SLIFunction ClonedictFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UndefFunction : public SLIFunction @@ -209,7 +209,7 @@ class UndefFunction : public SLIFunction UndefFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class KnownFunction : public SLIFunction @@ -218,7 +218,7 @@ class KnownFunction : public SLIFunction KnownFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cva_dFunction : public SLIFunction @@ -227,7 +227,7 @@ class Cva_dFunction : public SLIFunction Cva_dFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class KeysFunction : public SLIFunction @@ -236,7 +236,7 @@ class KeysFunction : public SLIFunction KeysFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ValuesFunction : public SLIFunction @@ -245,7 +245,7 @@ class ValuesFunction : public SLIFunction ValuesFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RestoredstackFunction : public SLIFunction @@ -254,7 +254,7 @@ class RestoredstackFunction : public SLIFunction RestoredstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/sliexceptions.h b/sli/sliexceptions.h index 2a8cef84f4..f8d0ad8a42 100644 --- a/sli/sliexceptions.h +++ b/sli/sliexceptions.h @@ -71,7 +71,7 @@ class SLIException : public std::exception { } - virtual ~SLIException() throw() {}; + ~SLIException() throw() override {}; /** * Returns the SLI error name, used by raiseerror. @@ -90,8 +90,8 @@ class SLIException : public std::exception *@note The catch clause must be terminated with a return *statement, if raiseerror was called. */ - virtual const char* - what() const throw() + const char* + what() const throw() override { return what_.c_str(); } @@ -110,7 +110,7 @@ class SLIException : public std::exception class InterpreterError : public SLIException { public: - virtual ~InterpreterError() throw() + ~InterpreterError() throw() override { } @@ -131,11 +131,11 @@ class WrappedThreadException : public SLIException { public: WrappedThreadException( const std::exception& ); - virtual ~WrappedThreadException() throw() + ~WrappedThreadException() throw() override { } std::string - message() const + message() const override { return message_; } @@ -147,7 +147,7 @@ class WrappedThreadException : public SLIException class DivisionByZero : public SLIException { public: - virtual ~DivisionByZero() throw() + ~DivisionByZero() throw() override { } @@ -155,7 +155,7 @@ class DivisionByZero : public SLIException : SLIException( "DivisionByZero" ) { } - std::string message() const; + std::string message() const override; }; // -------------------- Type Mismatch ------------------------- @@ -171,7 +171,7 @@ class TypeMismatch : public InterpreterError // SLIException std::string provided_; public: - ~TypeMismatch() throw() + ~TypeMismatch() throw() override { } @@ -193,7 +193,7 @@ class TypeMismatch : public InterpreterError // SLIException { } - std::string message() const; + std::string message() const override; }; class SystemSignal : public InterpreterError @@ -201,7 +201,7 @@ class SystemSignal : public InterpreterError int signal_; public: - ~SystemSignal() throw() + ~SystemSignal() throw() override { } SystemSignal( int s ) @@ -210,7 +210,7 @@ class SystemSignal : public InterpreterError { } - std::string message() const; + std::string message() const override; }; // -------------------- Array Size Mismatch ------------------------- @@ -223,7 +223,7 @@ class RangeCheck : public InterpreterError int size_; public: - ~RangeCheck() throw() + ~RangeCheck() throw() override { } @@ -233,7 +233,7 @@ class RangeCheck : public InterpreterError { } - std::string message() const; + std::string message() const override; }; class ArgumentType : public InterpreterError @@ -246,7 +246,7 @@ class ArgumentType : public InterpreterError { } - std::string message() const; + std::string message() const override; }; /** @@ -271,11 +271,11 @@ class BadParameterValue : public SLIException { } - ~BadParameterValue() throw() + ~BadParameterValue() throw() override { } - std::string message() const; + std::string message() const override; }; // -------------------- Dict Error ------------------------- @@ -286,7 +286,7 @@ class BadParameterValue : public SLIException class DictError : public InterpreterError { public: - virtual ~DictError() throw() + ~DictError() throw() override { } @@ -307,7 +307,7 @@ class UndefinedName : public DictError // was UnknownName std::string name_; public: - ~UndefinedName() throw() + ~UndefinedName() throw() override { } UndefinedName( const std::string& name ) @@ -316,7 +316,7 @@ class UndefinedName : public DictError // was UnknownName { } - std::string message() const; + std::string message() const override; }; // -------------------- Entry Type Mismatch ------------------------- @@ -331,7 +331,7 @@ class EntryTypeMismatch : public DictError std::string provided_; public: - ~EntryTypeMismatch() throw() + ~EntryTypeMismatch() throw() override { } EntryTypeMismatch( const std::string& expectedType, const std::string& providedType ) @@ -341,7 +341,7 @@ class EntryTypeMismatch : public DictError { } - std::string message() const; + std::string message() const override; }; // -------------------- Stack Error ------------------------- @@ -360,7 +360,7 @@ class StackUnderflow : public InterpreterError , needed( n ) , given( g ) {}; - std::string message() const; + std::string message() const override; }; @@ -372,7 +372,7 @@ class StackUnderflow : public InterpreterError class IOError : public SLIException { public: - ~IOError() throw() + ~IOError() throw() override { } IOError() @@ -380,7 +380,7 @@ class IOError : public SLIException { } - std::string message() const; + std::string message() const override; }; /** @@ -391,7 +391,7 @@ class UnaccessedDictionaryEntry : public DictError std::string msg_; public: - ~UnaccessedDictionaryEntry() throw() + ~UnaccessedDictionaryEntry() throw() override { } // input: string with names of not accessed @@ -401,7 +401,7 @@ class UnaccessedDictionaryEntry : public DictError { } - std::string message() const; + std::string message() const override; }; @@ -418,7 +418,7 @@ class DynamicModuleManagementError : public SLIException std::string msg_; public: - ~DynamicModuleManagementError() throw() + ~DynamicModuleManagementError() throw() override { } @@ -434,7 +434,7 @@ class DynamicModuleManagementError : public SLIException { } - std::string message() const; + std::string message() const override; }; /** @@ -448,7 +448,7 @@ class NamingConflict : public SLIException std::string msg_; public: - ~NamingConflict() throw() + ~NamingConflict() throw() override { } NamingConflict( const std::string& m ) @@ -457,7 +457,7 @@ class NamingConflict : public SLIException { } - std::string message() const; + std::string message() const override; }; /** @@ -469,7 +469,7 @@ class NotImplemented : public SLIException std::string msg_; public: - ~NotImplemented() throw() + ~NotImplemented() throw() override { } NotImplemented( const std::string& m ) @@ -478,7 +478,7 @@ class NotImplemented : public SLIException { } - std::string message() const; + std::string message() const override; }; #endif diff --git a/sli/sligraphics.h b/sli/sligraphics.h index 872625acc9..d3b0cbba14 100644 --- a/sli/sligraphics.h +++ b/sli/sligraphics.h @@ -47,13 +47,13 @@ class SLIgraphics : public SLIModule void readImage( std::istream*, char[ 2 ], std::vector< long >&, int, int, int ) const; //!< reads the image public: - virtual void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class WritePGMFunction : public SLIFunction { public: - virtual void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; ReadPGMFunction readpgmfunction; @@ -64,9 +64,9 @@ class SLIgraphics : public SLIModule { } - void init( SLIInterpreter* ); - const std::string name() const; - const std::string commandstring() const; + void init( SLIInterpreter* ) override; + const std::string name() const override; + const std::string commandstring() const override; }; diff --git a/sli/slimath.h b/sli/slimath.h index 78baaf9f52..054f0cc3d5 100644 --- a/sli/slimath.h +++ b/sli/slimath.h @@ -37,7 +37,7 @@ class Add_diFunction : public SLIFunction Add_diFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_iiFunction : public SLIFunction @@ -46,7 +46,7 @@ class Add_iiFunction : public SLIFunction Add_iiFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_idFunction : public SLIFunction @@ -55,7 +55,7 @@ class Add_idFunction : public SLIFunction Add_idFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Add_ddFunction : public SLIFunction @@ -64,7 +64,7 @@ class Add_ddFunction : public SLIFunction Add_ddFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //--------------------------------------- @@ -74,7 +74,7 @@ class Sub_diFunction : public SLIFunction Sub_diFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sub_iiFunction : public SLIFunction @@ -84,7 +84,7 @@ class Sub_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sub_idFunction : public SLIFunction @@ -94,7 +94,7 @@ class Sub_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sub_ddFunction : public SLIFunction @@ -104,7 +104,7 @@ class Sub_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //--------------------------------------- @@ -115,7 +115,7 @@ class Mul_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_iiFunction : public SLIFunction @@ -125,7 +125,7 @@ class Mul_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_idFunction : public SLIFunction @@ -135,7 +135,7 @@ class Mul_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Mul_ddFunction : public SLIFunction @@ -145,7 +145,7 @@ class Mul_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //--------------------------------------- @@ -156,7 +156,7 @@ class Div_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Div_iiFunction : public SLIFunction @@ -166,7 +166,7 @@ class Div_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Div_idFunction : public SLIFunction @@ -176,7 +176,7 @@ class Div_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Div_ddFunction : public SLIFunction { @@ -185,7 +185,7 @@ class Div_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //-------------------------------------- @@ -197,7 +197,7 @@ class Mod_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //-------------------------------------- @@ -209,7 +209,7 @@ class Sin_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Asin_dFunction : public SLIFunction @@ -219,7 +219,7 @@ class Asin_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cos_dFunction : public SLIFunction @@ -229,7 +229,7 @@ class Cos_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Acos_dFunction : public SLIFunction @@ -239,7 +239,7 @@ class Acos_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Exp_dFunction : public SLIFunction @@ -249,7 +249,7 @@ class Exp_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Ln_dFunction : public SLIFunction @@ -259,7 +259,7 @@ class Ln_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Log_dFunction : public SLIFunction @@ -269,7 +269,7 @@ class Log_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sqr_dFunction : public SLIFunction @@ -279,7 +279,7 @@ class Sqr_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Sqrt_dFunction : public SLIFunction @@ -289,7 +289,7 @@ class Sqrt_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Pow_ddFunction : public SLIFunction @@ -299,7 +299,7 @@ class Pow_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Pow_diFunction : public SLIFunction @@ -309,7 +309,7 @@ class Pow_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Modf_dFunction : public SLIFunction @@ -319,7 +319,7 @@ class Modf_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Frexp_dFunction : public SLIFunction @@ -329,7 +329,7 @@ class Frexp_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Ldexp_diFunction : public SLIFunction @@ -339,7 +339,7 @@ class Ldexp_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -350,7 +350,7 @@ class Dexp_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -362,7 +362,7 @@ class Abs_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Abs_dFunction : public SLIFunction { @@ -371,7 +371,7 @@ class Abs_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //-------------------------------------- @@ -383,7 +383,7 @@ class Neg_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Neg_dFunction : public SLIFunction { @@ -392,7 +392,7 @@ class Neg_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Inv_dFunction : public SLIFunction @@ -402,7 +402,7 @@ class Inv_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; //------------------------- @@ -414,7 +414,7 @@ class EqFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class NeqFunction : public SLIFunction @@ -424,7 +424,7 @@ class NeqFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class AndFunction : public SLIFunction @@ -434,7 +434,7 @@ class AndFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OrFunction : public SLIFunction @@ -444,7 +444,7 @@ class OrFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class And_iiFunction : public SLIFunction @@ -454,7 +454,7 @@ class And_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Or_iiFunction : public SLIFunction @@ -464,7 +464,7 @@ class Or_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class XorFunction : public SLIFunction @@ -474,7 +474,7 @@ class XorFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Not_bFunction : public SLIFunction @@ -484,7 +484,7 @@ class Not_bFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Not_iFunction : public SLIFunction @@ -494,7 +494,7 @@ class Not_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Geq_iiFunction : public SLIFunction @@ -504,7 +504,7 @@ class Geq_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Geq_idFunction : public SLIFunction @@ -514,7 +514,7 @@ class Geq_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Geq_diFunction : public SLIFunction @@ -524,7 +524,7 @@ class Geq_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Geq_ddFunction : public SLIFunction @@ -534,7 +534,7 @@ class Geq_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Leq_iiFunction : public SLIFunction @@ -544,7 +544,7 @@ class Leq_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Leq_idFunction : public SLIFunction @@ -554,7 +554,7 @@ class Leq_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Leq_diFunction : public SLIFunction @@ -564,7 +564,7 @@ class Leq_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Leq_ddFunction : public SLIFunction @@ -574,7 +574,7 @@ class Leq_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -587,7 +587,7 @@ class Gt_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Gt_ddFunction : public SLIFunction @@ -597,7 +597,7 @@ class Gt_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Gt_idFunction : public SLIFunction @@ -607,7 +607,7 @@ class Gt_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Gt_diFunction : public SLIFunction @@ -617,7 +617,7 @@ class Gt_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Gt_ssFunction : public SLIFunction @@ -627,7 +627,7 @@ class Gt_ssFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Lt_iiFunction : public SLIFunction @@ -637,7 +637,7 @@ class Lt_iiFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Lt_ddFunction : public SLIFunction @@ -647,7 +647,7 @@ class Lt_ddFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Lt_idFunction : public SLIFunction @@ -657,7 +657,7 @@ class Lt_idFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Lt_diFunction : public SLIFunction @@ -667,7 +667,7 @@ class Lt_diFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Lt_ssFunction : public SLIFunction @@ -677,7 +677,7 @@ class Lt_ssFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IntegerFunction : public SLIFunction @@ -687,7 +687,7 @@ class IntegerFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DoubleFunction : public SLIFunction @@ -697,7 +697,7 @@ class DoubleFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UnitStep_iFunction : public SLIFunction @@ -707,7 +707,7 @@ class UnitStep_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UnitStep_dFunction : public SLIFunction @@ -717,7 +717,7 @@ class UnitStep_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UnitStep_iaFunction : public SLIFunction @@ -727,7 +727,7 @@ class UnitStep_iaFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class UnitStep_daFunction : public SLIFunction @@ -737,7 +737,7 @@ class UnitStep_daFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Round_dFunction : public SLIFunction @@ -746,7 +746,7 @@ class Round_dFunction : public SLIFunction Round_dFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Floor_dFunction : public SLIFunction @@ -756,7 +756,7 @@ class Floor_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Ceil_dFunction : public SLIFunction @@ -766,7 +766,7 @@ class Ceil_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -777,7 +777,7 @@ class Max_i_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Max_i_dFunction : public SLIFunction { @@ -786,7 +786,7 @@ class Max_i_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Max_d_iFunction : public SLIFunction { @@ -795,7 +795,7 @@ class Max_d_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Max_d_dFunction : public SLIFunction { @@ -804,7 +804,7 @@ class Max_d_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; @@ -815,7 +815,7 @@ class Min_i_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Min_i_dFunction : public SLIFunction { @@ -824,7 +824,7 @@ class Min_i_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Min_d_iFunction : public SLIFunction { @@ -833,7 +833,7 @@ class Min_d_iFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Min_d_dFunction : public SLIFunction { @@ -842,7 +842,7 @@ class Min_d_dFunction : public SLIFunction { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/sliregexp.h b/sli/sliregexp.h index 2a0df377c6..a8afd1757f 100644 --- a/sli/sliregexp.h +++ b/sli/sliregexp.h @@ -50,17 +50,17 @@ class RegexpModule : public SLIModule class RegcompFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RegexecFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RegerrorFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; public: @@ -114,11 +114,11 @@ class RegexpModule : public SLIModule { } - ~RegexpModule(); + ~RegexpModule() override; - void init( SLIInterpreter* ); - const std::string name() const; - const std::string commandstring() const; + void init( SLIInterpreter* ) override; + const std::string name() const override; + const std::string commandstring() const override; }; #endif diff --git a/sli/slistack.h b/sli/slistack.h index 6b9453e3f0..df85a801f1 100644 --- a/sli/slistack.h +++ b/sli/slistack.h @@ -41,7 +41,7 @@ class PopFunction : public SLIFunction PopFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class NpopFunction : public SLIFunction @@ -50,7 +50,7 @@ class NpopFunction : public SLIFunction NpopFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class DupFunction : public SLIFunction @@ -59,7 +59,7 @@ class DupFunction : public SLIFunction DupFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ExchFunction : public SLIFunction @@ -68,7 +68,7 @@ class ExchFunction : public SLIFunction ExchFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class IndexFunction : public SLIFunction @@ -77,7 +77,7 @@ class IndexFunction : public SLIFunction IndexFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RollFunction : public SLIFunction @@ -86,7 +86,7 @@ class RollFunction : public SLIFunction RollFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RolluFunction : public SLIFunction @@ -95,7 +95,7 @@ class RolluFunction : public SLIFunction RolluFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RolldFunction : public SLIFunction @@ -104,7 +104,7 @@ class RolldFunction : public SLIFunction RolldFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RotFunction : public SLIFunction @@ -113,7 +113,7 @@ class RotFunction : public SLIFunction RotFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OverFunction : public SLIFunction @@ -122,7 +122,7 @@ class OverFunction : public SLIFunction OverFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CountFunction : public SLIFunction @@ -131,7 +131,7 @@ class CountFunction : public SLIFunction CountFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class CopyFunction : public SLIFunction @@ -140,7 +140,7 @@ class CopyFunction : public SLIFunction CopyFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ClearFunction : public SLIFunction @@ -149,7 +149,7 @@ class ClearFunction : public SLIFunction ClearFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class ExecstackFunction : public SLIFunction @@ -158,7 +158,7 @@ class ExecstackFunction : public SLIFunction ExecstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RestoreestackFunction : public SLIFunction @@ -167,7 +167,7 @@ class RestoreestackFunction : public SLIFunction RestoreestackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class RestoreostackFunction : public SLIFunction @@ -176,7 +176,7 @@ class RestoreostackFunction : public SLIFunction RestoreostackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class OperandstackFunction : public SLIFunction @@ -185,6 +185,6 @@ class OperandstackFunction : public SLIFunction OperandstackFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; #endif diff --git a/sli/slistartup.h b/sli/slistartup.h index 3a46c239b1..9454a1c6b7 100644 --- a/sli/slistartup.h +++ b/sli/slistartup.h @@ -135,20 +135,20 @@ class SLIStartup : public SLIModule class GetenvFunction : public SLIFunction { public: - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; GetenvFunction getenvfunction; SLIStartup( int, char** ); - ~SLIStartup() + ~SLIStartup() override { } - void init( SLIInterpreter* ); + void init( SLIInterpreter* ) override; const std::string - name() const + name() const override { return "SLIStartup"; } diff --git a/sli/slitypecheck.h b/sli/slitypecheck.h index 57d1344dd3..ba2ddb29e3 100644 --- a/sli/slitypecheck.h +++ b/sli/slitypecheck.h @@ -35,7 +35,7 @@ class TrieFunction : public SLIFunction TrieFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class TrieInfoFunction : public SLIFunction @@ -44,7 +44,7 @@ class TrieInfoFunction : public SLIFunction TrieInfoFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class AddtotrieFunction : public SLIFunction @@ -53,7 +53,7 @@ class AddtotrieFunction : public SLIFunction AddtotrieFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cva_tFunction : public SLIFunction @@ -62,7 +62,7 @@ class Cva_tFunction : public SLIFunction Cva_tFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class Cvt_aFunction : public SLIFunction @@ -71,7 +71,7 @@ class Cvt_aFunction : public SLIFunction Cvt_aFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; class TypeFunction : public SLIFunction @@ -80,7 +80,7 @@ class TypeFunction : public SLIFunction TypeFunction() { } - void execute( SLIInterpreter* ) const; + void execute( SLIInterpreter* ) const override; }; From 80c7dd4bd172ac0bd488e1de34db07d4923e4314 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Fri, 7 Oct 2022 16:43:45 +0200 Subject: [PATCH 101/150] Clean up include descriptions for consistency --- models/modelsmodule.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/models/modelsmodule.cpp b/models/modelsmodule.cpp index 6bfabcdf00..d61a30182d 100644 --- a/models/modelsmodule.cpp +++ b/models/modelsmodule.cpp @@ -22,7 +22,7 @@ #include "modelsmodule.h" -// Includes from nestkernel: +// Includes from nestkernel #include "common_synapse_properties.h" #include "connector_model_impl.h" #include "genericmodel.h" @@ -32,10 +32,9 @@ #include "model_manager_impl.h" #include "target_identifier.h" -// Generated includes: +// Generated includes #include "config.h" - // Neuron models #include "aeif_cond_alpha.h" #include "aeif_cond_alpha_multisynapse.h" @@ -124,7 +123,7 @@ #include "volume_transmitter.h" #include "weight_recorder.h" -// Prototypes for synapses +// Synapse models #include "bernoulli_synapse.h" #include "clopath_synapse.h" #include "common_synapse_properties.h" From 94a9c2d8285999a7cbaf574bedf38d8eab2bbb7e Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Fri, 7 Oct 2022 16:44:58 +0200 Subject: [PATCH 102/150] Remove unneeded include --- nestkernel/clopath_archiving_node.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/nestkernel/clopath_archiving_node.cpp b/nestkernel/clopath_archiving_node.cpp index 5f20ed84c5..4617c78829 100644 --- a/nestkernel/clopath_archiving_node.cpp +++ b/nestkernel/clopath_archiving_node.cpp @@ -24,7 +24,6 @@ // Includes from nestkernel: #include "kernel_manager.h" -#include "secondary_event.h" // Includes from sli: #include "dictutils.h" From df41a129f779575cace6fa685db7327cfe62d8c9 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Fri, 7 Oct 2022 16:45:53 +0200 Subject: [PATCH 103/150] Fix code style --- nestkernel/secondary_event.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/nestkernel/secondary_event.h b/nestkernel/secondary_event.h index 54d39a5c82..791af45675 100644 --- a/nestkernel/secondary_event.h +++ b/nestkernel/secondary_event.h @@ -167,7 +167,8 @@ class DataSecondaryEvent : public SecondaryEvent static std::vector< synindex > supported_syn_ids_; static size_t coeff_length_; // length of coeffarray - union CoeffarrayBegin { + union CoeffarrayBegin + { std::vector< unsigned int >::iterator as_uint; typename std::vector< DataType >::iterator as_d; @@ -175,7 +176,8 @@ class DataSecondaryEvent : public SecondaryEvent // non-trivial constructors of iterators } coeffarray_begin_; - union CoeffarrayEnd { + union CoeffarrayEnd + { std::vector< unsigned int >::iterator as_uint; typename std::vector< DataType >::iterator as_d; From 49afa39bc34bfb818ff0e6a3f18387bdfb9cc79f Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Fri, 7 Oct 2022 17:11:28 +0200 Subject: [PATCH 104/150] Simplify runner variable definition --- nestkernel/event_delivery_manager_impl.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/nestkernel/event_delivery_manager_impl.h b/nestkernel/event_delivery_manager_impl.h index a0d03096d7..0430c61cc5 100644 --- a/nestkernel/event_delivery_manager_impl.h +++ b/nestkernel/event_delivery_manager_impl.h @@ -152,8 +152,7 @@ EventDeliveryManager::send_secondary( Node& source, SecondaryEvent& e ) // make sure also labeled and connection created by CopyModel are // considered. const std::vector< synindex >& supported_syn_ids = e.get_supported_syn_ids(); - for ( std::vector< synindex >::const_iterator cit = supported_syn_ids.begin(); cit != supported_syn_ids.end(); - ++cit ) + for ( auto cit = supported_syn_ids.begin(); cit != supported_syn_ids.end(); ++cit ) { const std::vector< size_t >& positions = kernel().connection_manager.get_secondary_send_buffer_positions( tid, lid, *cit ); From 591c458f9539eb98467b6ab35f9ce99874f3f83a Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Fri, 7 Oct 2022 17:14:31 +0200 Subject: [PATCH 105/150] Remove superfluous data structure for secondary events and pertaining code --- nestkernel/connection_manager.cpp | 4 ---- nestkernel/model_manager.cpp | 23 +---------------------- nestkernel/model_manager.h | 27 +++------------------------ nestkernel/simulation_manager.cpp | 2 -- nestkernel/sp_manager.cpp | 7 ------- 5 files changed, 4 insertions(+), 59 deletions(-) diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index e605efff25..76c58cf72f 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -981,10 +981,6 @@ nest::ConnectionManager::get_connections( const DictionaryDatum& params ) // as this may involve sorting connections by source node IDs. if ( connections_have_changed() ) { - if ( not kernel().simulation_manager.has_been_simulated() ) - { - kernel().model_manager.create_secondary_events_prototypes(); - } #pragma omp parallel { const thread tid = kernel().vp_manager.get_thread_id(); diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 08a2183de9..b0eaedfcec 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -137,7 +137,6 @@ ModelManager::finalize() { clear_node_models_(); clear_connection_models_(); - delete_secondary_events_prototypes(); // We free all Node memory for ( auto& node_model : builtin_node_models_ ) @@ -282,7 +281,7 @@ ModelManager::copy_connection_model_( index old_id, Name new_name ) // has to be mapped to the corresponding secondary event type if ( not get_connection_model( old_id ).is_primary() ) { - ( get_connection_model( old_id ).get_event() )->add_syn_id( new_id ); + get_connection_model( old_id ).get_event()->add_syn_id( new_id ); } for ( thread t = 0; t < static_cast< thread >( kernel().vp_manager.get_num_threads() ); ++t ) @@ -548,26 +547,6 @@ ModelManager::memory_info() const std::cout.unsetf( std::ios::left ); } -void -ModelManager::create_secondary_events_prototypes() -{ - delete_secondary_events_prototypes(); - secondary_events_prototypes_.resize( kernel().vp_manager.get_num_threads() ); - - for ( thread tid = 0; tid < static_cast< thread >( kernel().vp_manager.get_num_threads() ); ++tid ) - { - secondary_events_prototypes_[ tid ].clear(); - for ( synindex syn_id = 0; syn_id < connection_models_[ tid ].size(); ++syn_id ) - { - if ( not connection_models_[ tid ][ syn_id ]->is_primary() ) - { - secondary_events_prototypes_[ tid ].insert( - std::pair< synindex, SecondaryEvent* >( syn_id, connection_models_[ tid ][ syn_id ]->create_event() ) ); - } - } - } -} - synindex ModelManager::register_connection_model_( ConnectorModel* cf ) { diff --git a/nestkernel/model_manager.h b/nestkernel/model_manager.h index 0f22e34519..c58dd246fb 100644 --- a/nestkernel/model_manager.h +++ b/nestkernel/model_manager.h @@ -190,11 +190,7 @@ class ModelManager : public ManagerInterface */ void memory_info() const; - void create_secondary_events_prototypes(); - - void delete_secondary_events_prototypes(); - - SecondaryEvent& get_secondary_event_prototype( const synindex syn_id, const thread tid ) const; + SecondaryEvent& get_secondary_event_prototype( const synindex syn_id, const thread tid ); private: void clear_node_models_(); @@ -272,8 +268,6 @@ class ModelManager : public ManagerInterface */ std::vector< std::vector< ConnectorModel* > > connection_models_; - std::vector< std::map< synindex, SecondaryEvent* > > secondary_events_prototypes_; - DictionaryDatum modeldict_; //!< Dictionary of all node models DictionaryDatum synapsedict_; //!< Dictionary of all synapse models @@ -330,26 +324,11 @@ ModelManager::assert_valid_syn_id( synindex syn_id, thread t ) const } } -inline void -ModelManager::delete_secondary_events_prototypes() -{ - for ( auto it = secondary_events_prototypes_.begin(); it != secondary_events_prototypes_.end(); ++it ) - { - for ( std::map< synindex, SecondaryEvent* >::iterator iit = it->begin(); iit != it->end(); ++iit ) - { - ( *iit->second ).reset_supported_syn_ids(); - delete iit->second; - } - } - secondary_events_prototypes_.clear(); -} - inline SecondaryEvent& -ModelManager::get_secondary_event_prototype( const synindex syn_id, const thread tid ) const +ModelManager::get_secondary_event_prototype( const synindex syn_id, const thread tid ) { assert_valid_syn_id( syn_id ); - // Using .at() because operator[] does not guarantee constness. - return *( secondary_events_prototypes_[ tid ].at( syn_id ) ); + return *get_connection_model( syn_id, tid ).get_event(); } } // namespace nest diff --git a/nestkernel/simulation_manager.cpp b/nestkernel/simulation_manager.cpp index 290ad243b6..861205b6a4 100644 --- a/nestkernel/simulation_manager.cpp +++ b/nestkernel/simulation_manager.cpp @@ -471,8 +471,6 @@ nest::SimulationManager::prepare() kernel().node_manager.ensure_valid_thread_local_ids(); kernel().node_manager.prepare_nodes(); - kernel().model_manager.create_secondary_events_prototypes(); - // we have to do enter_runtime after prepare_nodes, since we use // calibrate to map the ports of MUSIC devices, which has to be done // before enter_runtime diff --git a/nestkernel/sp_manager.cpp b/nestkernel/sp_manager.cpp index 1c4b0497f8..432c68aa15 100644 --- a/nestkernel/sp_manager.cpp +++ b/nestkernel/sp_manager.cpp @@ -268,13 +268,6 @@ SPManager::disconnect( NodeCollectionPTR sources, { if ( kernel().connection_manager.connections_have_changed() ) { - if ( kernel().connection_manager.secondary_connections_exist() ) - { - kernel().model_manager.create_secondary_events_prototypes(); // necessary before - // updating - // connection - // infrastructure - } #pragma omp parallel { const thread tid = kernel().vp_manager.get_thread_id(); From c13cb1cd0f3cd7004195f4837ebaadc51aff3537 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 17:26:37 +0200 Subject: [PATCH 106/150] Removed all != nullptr checks by implicit pointer to bool cnversion --- models/aeif_cond_alpha_multisynapse.cpp | 4 +- models/aeif_cond_beta_multisynapse.cpp | 4 +- models/cm_default.cpp | 8 +- models/cm_tree.cpp | 8 +- models/glif_cond.cpp | 4 +- models/stdp_dopamine_synapse.cpp | 2 +- models/stdp_dopamine_synapse.h | 2 +- nestkernel/conn_builder.cpp | 4 +- nestkernel/connection_manager.cpp | 34 +++---- nestkernel/connection_manager_impl.h | 2 +- nestkernel/connector_model_impl.h | 2 +- nestkernel/dynamicloader.cpp | 4 +- nestkernel/event.h | 6 +- nestkernel/io_manager.cpp | 2 +- nestkernel/layer_impl.h | 2 +- nestkernel/logging_manager.cpp | 2 +- nestkernel/model_manager.cpp | 14 +-- nestkernel/nestmodule.cpp | 2 +- nestkernel/node_manager.cpp | 6 +- nestkernel/sp_manager.cpp | 2 +- nestkernel/sp_manager_impl.h | 2 +- nestkernel/sparse_node_array.h | 2 +- nestkernel/stimulation_backend_mpi.cpp | 6 +- nestkernel/synaptic_element.cpp | 2 +- nestkernel/target_identifier.h | 2 +- nestkernel/target_table_devices.cpp | 4 +- nestkernel/target_table_devices.h | 2 +- nestkernel/target_table_devices_impl.h | 6 +- sli/dictstack.cc | 2 +- sli/dictutils.cc | 6 +- sli/dictutils.h | 10 +-- sli/filesystem.cc | 24 ++--- sli/gnureadline.cc | 4 +- sli/interpret.cc | 26 +++--- sli/oosupport.cc | 6 +- sli/parser.cc | 10 +-- sli/parser.h | 2 +- sli/processes.cc | 48 +++++----- sli/sli_io.cc | 12 +-- sli/sliactions.cc | 2 +- sli/sliarray.cc | 112 +++++++++++------------ sli/slibuiltins.cc | 30 +++---- sli/slidata.cc | 114 ++++++++++++------------ sli/slidict.cc | 38 ++++---- sli/slimath.cc | 32 +++---- sli/sliregexp.cc | 18 ++-- sli/slistack.cc | 10 +-- sli/slistartup.cc | 4 +- sli/slitypecheck.cc | 12 +-- sli/tarrayobj.cc | 6 +- sli/token.h | 4 +- sli/tokenarray.cc | 6 +- sli/tokenutils.cc | 10 +-- sli/triedatum.cc | 2 +- sli/triedatum.h | 2 +- sli/typechk.cc | 20 ++--- sli/typechk.h | 10 +-- 57 files changed, 361 insertions(+), 361 deletions(-) diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index 2d5e856b1a..1585af37cc 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -464,14 +464,14 @@ aeif_cond_alpha_multisynapse::pre_run_hook() State_::NUMBER_OF_FIXED_STATES_ELEMENTS + ( State_::NUM_STATE_ELEMENTS_PER_RECEPTOR * P_.n_receptors() ), 0.0 ); // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != nullptr ) + if ( B_.s_ ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != nullptr ) + if ( B_.e_ ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index d91f160e4c..320fe2cb25 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -473,14 +473,14 @@ aeif_cond_beta_multisynapse::pre_run_hook() State_::NUMBER_OF_FIXED_STATES_ELEMENTS + ( State_::NUM_STATE_ELEMENTS_PER_RECEPTOR * P_.n_receptors() ), 0.0 ); // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != nullptr ) + if ( B_.s_ ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != nullptr ) + if ( B_.e_ ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/cm_default.cpp b/models/cm_default.cpp index a5e849a569..482f1eda95 100644 --- a/models/cm_default.cpp +++ b/models/cm_default.cpp @@ -125,7 +125,7 @@ nest::cm_default::set_status( const DictionaryDatum& statusdict ) ArrayDatum* ad = dynamic_cast< ArrayDatum* >( dat ); DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( dat ); - if ( ad != nullptr ) + if ( ad ) { // A list of compartments is provided, we add them all to the tree for ( Token* tt = ( *ad ).begin(); tt != ( *ad ).end(); ++tt ) @@ -135,7 +135,7 @@ nest::cm_default::set_status( const DictionaryDatum& statusdict ) add_compartment_( *dynamic_cast< DictionaryDatum* >( tt->datum() ) ); } } - else if ( dd != nullptr ) + else if ( dd ) { // A single compartment is provided, we add add it to the tree add_compartment_( *dd ); @@ -170,7 +170,7 @@ nest::cm_default::set_status( const DictionaryDatum& statusdict ) ArrayDatum* ad = dynamic_cast< ArrayDatum* >( dat ); DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( dat ); - if ( ad != nullptr ) + if ( ad ) { for ( Token* tt = ( *ad ).begin(); tt != ( *ad ).end(); ++tt ) { @@ -179,7 +179,7 @@ nest::cm_default::set_status( const DictionaryDatum& statusdict ) add_receptor_( *dynamic_cast< DictionaryDatum* >( tt->datum() ) ); } } - else if ( dd != nullptr ) + else if ( dd ) { add_receptor_( *dd ); } diff --git a/models/cm_tree.cpp b/models/cm_tree.cpp index a944b85706..5874360d2e 100644 --- a/models/cm_tree.cpp +++ b/models/cm_tree.cpp @@ -115,7 +115,7 @@ nest::Compartment::construct_matrix_element( const long lag ) // matrix diagonal element gg = gg0; - if ( parent != nullptr ) + if ( parent ) { gg += gc__div__2; // matrix off diagonal element @@ -130,7 +130,7 @@ nest::Compartment::construct_matrix_element( const long lag ) // right hand side ff = ( ca__div__dt - gl__div__2 ) * v_comp + gl__times__el; - if ( parent != nullptr ) + if ( parent ) { ff -= gc__div__2 * ( v_comp - parent->v_comp ); } @@ -436,7 +436,7 @@ nest::CompTree::solve_matrix_downsweep( Compartment* compartment, std::vector< C std::pair< double, double > output = compartment->io(); // move on to the parent layer - if ( compartment->parent != nullptr ) + if ( compartment->parent ) { Compartment* parent = compartment->parent; // gather input from child layers @@ -488,7 +488,7 @@ nest::CompTree::print_tree() const std::cout << "C_m = " << compartment->ca << " nF, "; std::cout << "g_L = " << compartment->gl << " uS, "; std::cout << "e_L = " << compartment->el << " mV, "; - if ( compartment->parent != nullptr ) + if ( compartment->parent ) { std::cout << "Parent " << compartment->parent->comp_index << " --> "; std::cout << "g_c = " << compartment->gc << " uS, "; diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index a9985f2d47..e9a57bbfba 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -596,14 +596,14 @@ nest::glif_cond::pre_run_hook() } // reallocate instance of stepping function for ODE GSL solver - if ( B_.s_ != nullptr ) + if ( B_.s_ ) { gsl_odeiv_step_free( B_.s_ ); } B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, S_.y_.size() ); // reallocate instance of evolution function for ODE GSL solver - if ( B_.e_ != nullptr ) + if ( B_.e_ ) { gsl_odeiv_evolve_free( B_.e_ ); } diff --git a/models/stdp_dopamine_synapse.cpp b/models/stdp_dopamine_synapse.cpp index 432d84a1b6..fa90419e98 100644 --- a/models/stdp_dopamine_synapse.cpp +++ b/models/stdp_dopamine_synapse.cpp @@ -55,7 +55,7 @@ void STDPDopaCommonProperties::get_status( DictionaryDatum& d ) const { CommonSynapseProperties::get_status( d ); - if ( vt_ != nullptr ) + if ( vt_ ) { def< long >( d, names::vt, vt_->get_node_id() ); } diff --git a/models/stdp_dopamine_synapse.h b/models/stdp_dopamine_synapse.h index fd616c7f92..ea6eafeddb 100644 --- a/models/stdp_dopamine_synapse.h +++ b/models/stdp_dopamine_synapse.h @@ -175,7 +175,7 @@ class STDPDopaCommonProperties : public CommonSynapseProperties inline long STDPDopaCommonProperties::get_vt_node_id() const { - if ( vt_ != nullptr ) + if ( vt_ ) { return vt_->get_node_id(); } diff --git a/nestkernel/conn_builder.cpp b/nestkernel/conn_builder.cpp index 1e82c147fb..93bb7623d7 100644 --- a/nestkernel/conn_builder.cpp +++ b/nestkernel/conn_builder.cpp @@ -1755,14 +1755,14 @@ nest::SymmetricBernoulliBuilder::connect_() // if target is local: connect if ( target_thread == tid ) { - assert( target != nullptr ); + assert( target ); single_connect_( snode_id, *target, target_thread, synced_rng ); } // if source is local: connect if ( source_thread == tid ) { - assert( source != nullptr ); + assert( source ); single_connect_( ( *tnode_id ).node_id, *source, source_thread, synced_rng ); } diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index e43b50b8a1..9f344b4683 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -233,9 +233,9 @@ nest::ConnectionManager::get_synapse_status( const index source_node_id, // synapses from neurons to neurons and from neurons to globally // receiving devices - if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != nullptr ) + if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] ) or ( ( source->has_proxies() and not target->has_proxies() and not target->local_receiver() - and connections_[ tid ][ syn_id ] != nullptr ) ) ) + and connections_[ tid ][ syn_id ] ) ) ) { connections_[ tid ][ syn_id ]->get_synapse_status( tid, lcid, dict ); } @@ -274,9 +274,9 @@ nest::ConnectionManager::set_synapse_status( const index source_node_id, ConnectorModel& cm = kernel().model_manager.get_connection_model( syn_id, tid ); // synapses from neurons to neurons and from neurons to globally // receiving devices - if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] != nullptr ) + if ( ( source->has_proxies() and target->has_proxies() and connections_[ tid ][ syn_id ] ) or ( ( source->has_proxies() and not target->has_proxies() and not target->local_receiver() - and connections_[ tid ][ syn_id ] != nullptr ) ) ) + and connections_[ tid ][ syn_id ] ) ) ) { connections_[ tid ][ syn_id ]->set_synapse_status( lcid, dict, cm ); } @@ -416,7 +416,7 @@ nest::ConnectionManager::connect( NodeCollectionPTR sources, const long rule_id = ( *connruledict_ )[ rule_name ]; ConnBuilder* cb = connbuilder_factories_.at( rule_id )->create( sources, targets, conn_spec, syn_specs ); - assert( cb != nullptr ); + assert( cb ); // at this point, all entries in conn_spec and syn_spec have been checked ALL_ENTRIES_ACCESSED( *conn_spec, "Connect", "Unread dictionary entries in conn_spec: " ); @@ -611,7 +611,7 @@ nest::ConnectionManager::connect_arrays( long* sources, } // If the default value is an integer, the synapse parameter must also be an integer. - if ( dynamic_cast< IntegerDatum* >( syn_model_default_it->second.datum() ) != nullptr ) + if ( dynamic_cast< IntegerDatum* >( syn_model_default_it->second.datum() ) ) { param_pointers[ param_key ].second = true; ( *param_dicts[ i ] )[ param_key ] = Token( new IntegerDatum( 0 ) ); @@ -626,11 +626,11 @@ nest::ConnectionManager::connect_arrays( long* sources, // Increments pointers to weight and delay, if they are specified. auto increment_wd = [ weights, delays ]( decltype( weights ) & w, decltype( delays ) & d ) { - if ( weights != nullptr ) + if ( weights ) { ++w; } - if ( delays != nullptr ) + if ( delays ) { ++d; } @@ -674,11 +674,11 @@ nest::ConnectionManager::connect_arrays( long* sources, // If weights or delays are specified, the buffers are replaced with the values. // If not, the buffers will be NaN and replaced by a default value by the connect function. - if ( weights != nullptr ) + if ( weights ) { weight_buffer = *w; } - if ( delays != nullptr ) + if ( delays ) { delay_buffer = *d; } @@ -909,7 +909,7 @@ nest::ConnectionManager::get_num_target_data( const thread tid ) const size_t num_connections = 0; for ( synindex syn_id = 0; syn_id < connections_[ tid ].size(); ++syn_id ) { - if ( connections_[ tid ][ syn_id ] != nullptr ) + if ( connections_[ tid ][ syn_id ] ) { num_connections += source_table_.num_unique_sources( tid, syn_id ); } @@ -1092,7 +1092,7 @@ nest::ConnectionManager::get_connections( std::deque< ConnectionID >& connectome std::deque< ConnectionID > conns_in_thread; ConnectorBase* connections = connections_[ tid ][ syn_id ]; - if ( connections != nullptr ) + if ( connections ) { // Passing target_node_id = 0 ignores target_node_id while getting connections. const size_t num_connections_in_thread = connections->size(); @@ -1130,7 +1130,7 @@ nest::ConnectionManager::get_connections( std::deque< ConnectionID >& connectome // Getting regular connections, if they exist. ConnectorBase* connections = connections_[ tid ][ syn_id ]; - if ( connections != nullptr ) + if ( connections ) { const size_t num_connections_in_thread = connections->size(); for ( index lcid = 0; lcid < num_connections_in_thread; ++lcid ) @@ -1182,7 +1182,7 @@ nest::ConnectionManager::get_connections( std::deque< ConnectionID >& connectome } const ConnectorBase* connections = connections_[ tid ][ syn_id ]; - if ( connections != nullptr ) + if ( connections ) { const size_t num_connections_in_thread = connections->size(); for ( index lcid = 0; lcid < num_connections_in_thread; ++lcid ) @@ -1254,7 +1254,7 @@ nest::ConnectionManager::get_source_node_ids_( const thread tid, std::vector< index >& sources ) { std::vector< index > source_lcids; - if ( connections_[ tid ][ syn_id ] != nullptr ) + if ( connections_[ tid ][ syn_id ] ) { connections_[ tid ][ syn_id ]->get_source_lcids( tid, tnode_id, source_lcids ); source_table_.get_source_node_ids( tid, syn_id, source_lcids, sources ); @@ -1314,7 +1314,7 @@ nest::ConnectionManager::sort_connections( const thread tid ) { for ( synindex syn_id = 0; syn_id < connections_[ tid ].size(); ++syn_id ) { - if ( connections_[ tid ][ syn_id ] != nullptr ) + if ( connections_[ tid ][ syn_id ] ) { connections_[ tid ][ syn_id ]->sort_connections( source_table_.get_thread_local_sources( tid )[ syn_id ] ); } @@ -1372,7 +1372,7 @@ nest::ConnectionManager::compute_compressed_secondary_recv_buffer_positions( con { std::vector< size_t >& positions = secondary_recv_buffer_pos_[ tid ][ syn_id ]; - if ( connections_[ tid ][ syn_id ] != nullptr ) + if ( connections_[ tid ][ syn_id ] ) { if ( not kernel().model_manager.get_connection_model( syn_id, tid ).is_primary() ) { diff --git a/nestkernel/connection_manager_impl.h b/nestkernel/connection_manager_impl.h index ca5534d61f..254393545d 100644 --- a/nestkernel/connection_manager_impl.h +++ b/nestkernel/connection_manager_impl.h @@ -44,7 +44,7 @@ ConnectionManager::register_conn_builder( const std::string& name ) { assert( not connruledict_->known( name ) ); GenericConnBuilderFactory* cb = new ConnBuilderFactory< ConnBuilder >(); - assert( cb != nullptr ); + assert( cb ); const int id = connbuilder_factories_.size(); connbuilder_factories_.push_back( cb ); connruledict_->insert( name, id ); diff --git a/nestkernel/connector_model_impl.h b/nestkernel/connector_model_impl.h index 544e22b768..1715d029c8 100644 --- a/nestkernel/connector_model_impl.h +++ b/nestkernel/connector_model_impl.h @@ -275,7 +275,7 @@ GenericConnectorModel< ConnectionT >::add_connection_( Node& src, // The following line will throw an exception, if it does not work. connection.check_connection( src, tgt, receptor_type, get_common_properties() ); - assert( connector != nullptr ); + assert( connector ); Connector< ConnectionT >* vc = static_cast< Connector< ConnectionT >* >( connector ); vc->push_back( connection ); diff --git a/nestkernel/dynamicloader.cpp b/nestkernel/dynamicloader.cpp index 7842faec2c..bb294aedaf 100644 --- a/nestkernel/dynamicloader.cpp +++ b/nestkernel/dynamicloader.cpp @@ -103,7 +103,7 @@ DynamicLoaderModule::~DynamicLoaderModule() // unload all loaded modules for ( vecDynModules::iterator it = dyn_modules.begin(); it != dyn_modules.end(); ++it ) { - if ( it->handle != nullptr ) + if ( it->handle ) { lt_dlclose( it->handle ); it->handle = nullptr; @@ -284,7 +284,7 @@ DynamicLoaderModule::init( SLIInterpreter* i ) int DynamicLoaderModule::registerLinkedModule( SLIModule* pModule ) { - assert( pModule != nullptr ); + assert( pModule ); getLinkedModules().push_back( pModule ); return getLinkedModules().size(); } diff --git a/nestkernel/event.h b/nestkernel/event.h index a9a419b2e5..2847077dae 100644 --- a/nestkernel/event.h +++ b/nestkernel/event.h @@ -680,7 +680,7 @@ DataLoggingRequest::record_from() const { // During simulation, events are created without recordables // information. On these, record_from() must not be called. - assert( record_from_ != nullptr ); + assert( record_from_ ); return *record_from_; } @@ -1278,13 +1278,13 @@ DiffusionConnectionEvent::get_diffusion_factor() const inline bool Event::sender_is_valid() const { - return sender_ != nullptr; + return sender_; } inline bool Event::receiver_is_valid() const { - return receiver_ != nullptr; + return receiver_; } inline bool diff --git a/nestkernel/io_manager.cpp b/nestkernel/io_manager.cpp index 621ee0e335..66946efe5e 100644 --- a/nestkernel/io_manager.cpp +++ b/nestkernel/io_manager.cpp @@ -83,7 +83,7 @@ IOManager::set_data_path_prefix_( const DictionaryDatum& dict ) if ( updateValue< std::string >( dict, names::data_path, tmp ) ) { DIR* testdir = opendir( tmp.c_str() ); - if ( testdir != nullptr ) + if ( testdir ) { data_path_ = tmp; // absolute path & directory exists closedir( testdir ); // we only opened it to check it exists diff --git a/nestkernel/layer_impl.h b/nestkernel/layer_impl.h index 07112a6189..c67d3d0a88 100644 --- a/nestkernel/layer_impl.h +++ b/nestkernel/layer_impl.h @@ -117,7 +117,7 @@ Layer< D >::connect( NodeCollectionPTR source_nc, // We need to extract the real pointer here to be able to cast to the // dimension-specific subclass. AbstractLayer* target_abs = target_layer.get(); - assert( target_abs != nullptr ); + assert( target_abs ); try { diff --git a/nestkernel/logging_manager.cpp b/nestkernel/logging_manager.cpp index 856312324c..9031716a23 100644 --- a/nestkernel/logging_manager.cpp +++ b/nestkernel/logging_manager.cpp @@ -68,7 +68,7 @@ nest::LoggingManager::get_status( DictionaryDatum& dict ) void nest::LoggingManager::register_logging_client( const deliver_logging_event_ptr callback ) { - assert( callback != nullptr ); + assert( callback ); client_callbacks_.push_back( callback ); } diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 46c60db765..c47fcaaebe 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -60,7 +60,7 @@ ModelManager::~ModelManager() clear_connection_models_(); for ( auto&& connection_model : builtin_connection_models_ ) { - if ( connection_model != nullptr ) + if ( connection_model ) { delete connection_model; } @@ -69,7 +69,7 @@ ModelManager::~ModelManager() clear_node_models_(); for ( auto&& node_model : builtin_node_models_ ) { - if ( node_model != nullptr ) + if ( node_model ) { delete node_model; } @@ -120,7 +120,7 @@ ModelManager::initialize() // (re-)append all synapse prototypes for ( auto&& connection_model : builtin_connection_models_ ) { - if ( connection_model != nullptr ) + if ( connection_model ) { std::string name = connection_model->get_name(); for ( thread t = 0; t < static_cast< thread >( kernel().vp_manager.get_num_threads() ); ++t ) @@ -377,7 +377,7 @@ ModelManager::get_node_model_id( const Name name ) const const Name model_name( name ); for ( int i = 0; i < ( int ) node_models_.size(); ++i ) { - assert( node_models_[ i ] != nullptr ); + assert( node_models_[ i ] ); if ( model_name == node_models_[ i ]->get_name() ) { return i; @@ -450,7 +450,7 @@ ModelManager::clear_node_models_() // init() for ( auto&& node_model : node_models_ ) { - if ( node_model != nullptr ) + if ( node_model ) { delete node_model; } @@ -474,7 +474,7 @@ ModelManager::clear_connection_models_() { for ( auto&& connection_model : connection_models_[ t ] ) { - if ( connection_model != nullptr ) + if ( connection_model ) { delete connection_model; } @@ -495,7 +495,7 @@ ModelManager::calibrate( const TimeConverter& tc ) { for ( auto&& connection_model : connection_models_[ t ] ) { - if ( connection_model != nullptr ) + if ( connection_model ) { connection_model->calibrate( tc ); } diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index 78aa65c9a6..e217bd4858 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -209,7 +209,7 @@ NestModule::create_mask( const Token& t ) else { - if ( mask != nullptr ) + if ( mask ) { // mask has already been defined throw BadProperty( "Mask definition dictionary contains extraneous items." ); } diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index a96e4eb498..71132f8a3f 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -94,7 +94,7 @@ NodeManager::get_status( index idx ) { Node* target = get_mpi_local_node_or_device_head( idx ); - assert( target != nullptr ); + assert( target ); DictionaryDatum d = target->get_status_base(); @@ -114,7 +114,7 @@ NodeManager::add_node( index model_id, long n ) } Model* model = kernel().model_manager.get_node_model( model_id ); - assert( model != nullptr ); + assert( model ); model->deprecation_warning( "Create" ); const index min_node_id = local_nodes_.at( 0 ).get_max_node_id() + 1; @@ -753,7 +753,7 @@ NodeManager::set_status( index node_id, const DictionaryDatum& d ) for ( thread t = 0; t < kernel().vp_manager.get_num_threads(); ++t ) { Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node != nullptr ) + if ( node ) { set_status_single_node_( *node, d ); } diff --git a/nestkernel/sp_manager.cpp b/nestkernel/sp_manager.cpp index 16c4a64b0f..f9f11fc461 100644 --- a/nestkernel/sp_manager.cpp +++ b/nestkernel/sp_manager.cpp @@ -315,7 +315,7 @@ SPManager::disconnect( NodeCollectionPTR sources, { cb = kernel().connection_manager.get_conn_builder( rule_name, sources, targets, conn_spec, { syn_spec } ); } - assert( cb != nullptr ); + assert( cb ); // at this point, all entries in conn_spec and syn_spec have been checked ALL_ENTRIES_ACCESSED( *conn_spec, "Connect", "Unread dictionary entries: " ); diff --git a/nestkernel/sp_manager_impl.h b/nestkernel/sp_manager_impl.h index 0efdca12ce..791ac78db2 100644 --- a/nestkernel/sp_manager_impl.h +++ b/nestkernel/sp_manager_impl.h @@ -41,7 +41,7 @@ SPManager::register_growth_curve( const std::string& name ) { assert( not growthcurvedict_->known( name ) ); GenericGrowthCurveFactory* nc = new GrowthCurveFactory< GrowthCurve >(); - assert( nc != nullptr ); + assert( nc ); const int id = growthcurve_factories_.size(); growthcurve_factories_.push_back( nc ); growthcurvedict_->insert( name, id ); diff --git a/nestkernel/sparse_node_array.h b/nestkernel/sparse_node_array.h index f0079d5a9a..027e848daf 100644 --- a/nestkernel/sparse_node_array.h +++ b/nestkernel/sparse_node_array.h @@ -263,7 +263,7 @@ nest::SparseNodeArray::is_consistent_() const inline nest::Node* nest::SparseNodeArray::NodeEntry::get_node() const { - assert( node_ != nullptr ); + assert( node_ ); return node_; } diff --git a/nestkernel/stimulation_backend_mpi.cpp b/nestkernel/stimulation_backend_mpi.cpp index db1e930271..1adafa49ea 100644 --- a/nestkernel/stimulation_backend_mpi.cpp +++ b/nestkernel/stimulation_backend_mpi.cpp @@ -354,7 +354,7 @@ nest::StimulationBackendMPI::update_device( int* array_index, std::vector< int >& devices_id, std::pair< int*, double* > data ) { - if ( data.first != nullptr ) + if ( data.first ) { // if there is some device if ( data.first[ 0 ] != 0 ) @@ -400,13 +400,13 @@ nest::StimulationBackendMPI::clean_memory_input_data( std::vector< std::pair< in // for all the pairs of data, free the memory of data and the array with the size for ( auto pair_data : data ) { - if ( pair_data.first != nullptr ) + if ( pair_data.first ) { // clean the memory allocated in the function receive_spike_train delete[] pair_data.first; pair_data.first = nullptr; } - if ( pair_data.second != nullptr ) + if ( pair_data.second ) { // clean the memory allocated in the function receive_spike_train delete[] pair_data.second; diff --git a/nestkernel/synaptic_element.cpp b/nestkernel/synaptic_element.cpp index 90e4162752..9d83a33870 100644 --- a/nestkernel/synaptic_element.cpp +++ b/nestkernel/synaptic_element.cpp @@ -61,7 +61,7 @@ nest::SynapticElement::SynapticElement( const SynapticElement& se ) , tau_vacant_( se.tau_vacant_ ) { growth_curve_ = kernel().sp_manager.new_growth_curve( se.growth_curve_->get_name() ); - assert( growth_curve_ != nullptr ); + assert( growth_curve_ ); DictionaryDatum nc_parameters = DictionaryDatum( new Dictionary ); se.get( nc_parameters ); growth_curve_->set( nc_parameters ); diff --git a/nestkernel/target_identifier.h b/nestkernel/target_identifier.h index f0152958d0..384ae30ff5 100644 --- a/nestkernel/target_identifier.h +++ b/nestkernel/target_identifier.h @@ -63,7 +63,7 @@ class TargetIdentifierPtrRport get_status( DictionaryDatum& d ) const { // Do nothing if called on synapse prototype - if ( target_ != nullptr ) + if ( target_ ) { def< long >( d, names::rport, rport_ ); def< long >( d, names::target, target_->get_node_id() ); diff --git a/nestkernel/target_table_devices.cpp b/nestkernel/target_table_devices.cpp index 8687cb8736..ee3b311f3d 100644 --- a/nestkernel/target_table_devices.cpp +++ b/nestkernel/target_table_devices.cpp @@ -142,7 +142,7 @@ nest::TargetTableDevices::get_connections_to_device_for_lid_( const index lid, { const index source_node_id = kernel().vp_manager.lid_to_node_id( lid ); // not the valid connector - if ( source_node_id > 0 and target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) + if ( source_node_id > 0 and target_to_devices_[ tid ][ lid ][ syn_id ] ) { target_to_devices_[ tid ][ lid ][ syn_id ]->get_all_connections( source_node_id, requested_target_node_id, tid, synapse_label, conns ); @@ -171,7 +171,7 @@ nest::TargetTableDevices::get_connections_from_devices_( const index requested_s if ( target_from_devices_[ tid ][ ldid ].size() > 0 ) { // not the valid connector - if ( target_from_devices_[ tid ][ ldid ][ syn_id ] != nullptr ) + if ( target_from_devices_[ tid ][ ldid ][ syn_id ] ) { target_from_devices_[ tid ][ ldid ][ syn_id ]->get_all_connections( source_node_id, requested_target_node_id, tid, synapse_label, conns ); diff --git a/nestkernel/target_table_devices.h b/nestkernel/target_table_devices.h index 1a15e4b15c..f80d360a35 100644 --- a/nestkernel/target_table_devices.h +++ b/nestkernel/target_table_devices.h @@ -251,7 +251,7 @@ TargetTableDevices::is_device_connected( const thread tid, const index lcid ) co { for ( auto& synapse : target_from_devices_[ tid ][ lcid ] ) { - if ( synapse != nullptr ) + if ( synapse ) { std::deque< ConnectionID > conns; synapse->get_all_connections( lcid, 0, tid, UNLABELED_CONNECTION, conns ); diff --git a/nestkernel/target_table_devices_impl.h b/nestkernel/target_table_devices_impl.h index c7624637ea..cf29786c9e 100644 --- a/nestkernel/target_table_devices_impl.h +++ b/nestkernel/target_table_devices_impl.h @@ -100,7 +100,7 @@ nest::TargetTableDevices::send_to_device( const thread tid, const std::vector< synindex >& supported_syn_ids = e.get_supported_syn_ids(); for ( std::vector< synindex >::const_iterator cit = supported_syn_ids.begin(); cit != supported_syn_ids.end(); ++cit ) { - if ( target_to_devices_[ tid ][ lid ][ *cit ] != nullptr ) + if ( target_to_devices_[ tid ][ lid ][ *cit ] ) { target_to_devices_[ tid ][ lid ][ *cit ]->send_to_all( tid, cm, e ); } @@ -115,7 +115,7 @@ nest::TargetTableDevices::get_synapse_status_to_device( const thread tid, const index lcid ) const { const index lid = kernel().vp_manager.node_id_to_lid( source_node_id ); - if ( target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) + if ( target_to_devices_[ tid ][ lid ][ syn_id ] ) { target_to_devices_[ tid ][ lid ][ syn_id ]->get_synapse_status( tid, lcid, dict ); } @@ -130,7 +130,7 @@ nest::TargetTableDevices::set_synapse_status_to_device( const thread tid, const index lcid ) { const index lid = kernel().vp_manager.node_id_to_lid( source_node_id ); - if ( target_to_devices_[ tid ][ lid ][ syn_id ] != nullptr ) + if ( target_to_devices_[ tid ][ lid ][ syn_id ] ) { target_to_devices_[ tid ][ lid ][ syn_id ]->set_synapse_status( lcid, dict, cm ); } diff --git a/sli/dictstack.cc b/sli/dictstack.cc index b741aa4d2f..725fd8abbd 100644 --- a/sli/dictstack.cc +++ b/sli/dictstack.cc @@ -156,7 +156,7 @@ void DictionaryStack::push( Token& d ) { DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( d.datum() ); - assert( dd != nullptr ); + assert( dd ); push( *dd ); } diff --git a/sli/dictutils.cc b/sli/dictutils.cc index 6a30c93156..b6f0201017 100644 --- a/sli/dictutils.cc +++ b/sli/dictutils.cc @@ -61,7 +61,7 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< double > Token t = d->lookup2( propname ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add { @@ -79,7 +79,7 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< long >& Token t = d->lookup2( propname ); IntVectorDatum* arrd = dynamic_cast< IntVectorDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add { @@ -96,7 +96,7 @@ accumulate_property( DictionaryDatum& d, Name propname, const std::vector< doubl Token t = d->lookup2( propname ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); if ( ( *arrd )->empty() ) // first data, copy { diff --git a/sli/dictutils.h b/sli/dictutils.h index 8418c8205f..856d4d599f 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -93,7 +93,7 @@ get_double_in_range( const DictionaryDatum& d, Name const n, double min, double DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); double x = std::numeric_limits< double >::quiet_NaN(); - if ( dd != nullptr ) + if ( dd ) { x = dd->get(); } @@ -157,7 +157,7 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i DoubleDatum* dd = dynamic_cast< DoubleDatum* >( t.datum() ); long x = std::numeric_limits< long >::min(); - if ( dd != nullptr ) + if ( dd ) { x = dd->get(); } @@ -303,7 +303,7 @@ append_property( DictionaryDatum& d, Name propname, const PropT& prop ) assert( not t.empty() ); ArrayDatum* arrd = dynamic_cast< ArrayDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); Token prop_token( prop ); arrd->push_back_dont_clone( prop_token ); @@ -321,7 +321,7 @@ append_property< std::vector< double > >( DictionaryDatum& d, Name propname, con assert( not t.empty() ); DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } @@ -339,7 +339,7 @@ append_property< std::vector< long > >( DictionaryDatum& d, Name propname, const assert( not t.empty() ); IntVectorDatum* arrd = dynamic_cast< IntVectorDatum* >( t.datum() ); - assert( arrd != nullptr ); + assert( arrd ); ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } diff --git a/sli/filesystem.cc b/sli/filesystem.cc index d034cdf502..89122a4475 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -76,16 +76,16 @@ void FilesystemModule::FileNamesFunction::execute( SLIInterpreter* i ) const { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); DIR* TheDirectory = opendir( sd->c_str() ); - if ( TheDirectory != nullptr ) + if ( TheDirectory ) { ArrayDatum* a = new ArrayDatum(); i->EStack.pop(); i->OStack.pop(); dirent* TheEntry; - while ( ( TheEntry = readdir( TheDirectory ) ) != nullptr ) + while ( ( TheEntry = readdir( TheDirectory ) ) ) { Token string_token( new StringDatum( TheEntry->d_name ) ); a->push_back_move( string_token ); @@ -104,7 +104,7 @@ FilesystemModule::SetDirectoryFunction::execute( SLIInterpreter* i ) const // string -> boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); int s = chdir( sd->c_str() ); i->OStack.pop(); if ( not s ) @@ -148,7 +148,7 @@ FilesystemModule::DirectoryFunction::execute( SLIInterpreter* i ) const delete[] path_buffer; size += SIZE; path_buffer = new char[ size ]; - assert( path_buffer != nullptr ); + assert( path_buffer ); } Token sd( new StringDatum( path_buffer ) ); delete[]( path_buffer ); @@ -162,8 +162,8 @@ FilesystemModule::MoveFileFunction::execute( SLIInterpreter* i ) const { StringDatum* src = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* dst = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( src != nullptr ); - assert( dst != nullptr ); + assert( src ); + assert( dst ); int s = link( src->c_str(), dst->c_str() ); if ( not s ) { @@ -192,8 +192,8 @@ FilesystemModule::CopyFileFunction::execute( SLIInterpreter* i ) const { StringDatum* src = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* dst = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( src != nullptr ); - assert( dst != nullptr ); + assert( src ); + assert( dst ); std::ofstream deststream( dst->c_str() ); if ( not deststream ) @@ -232,7 +232,7 @@ FilesystemModule::DeleteFileFunction::execute( SLIInterpreter* i ) const // string -> boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); int s = unlink( sd->c_str() ); i->OStack.pop(); if ( not s ) @@ -251,7 +251,7 @@ FilesystemModule::MakeDirectoryFunction::execute( SLIInterpreter* i ) const // string -> Boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); int s = mkdir( sd->c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP ); i->OStack.pop(); if ( not s ) @@ -270,7 +270,7 @@ FilesystemModule::RemoveDirectoryFunction::execute( SLIInterpreter* i ) const // string -> Boolean { StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); int s = rmdir( sd->c_str() ); i->OStack.pop(); if ( not s ) diff --git a/sli/gnureadline.cc b/sli/gnureadline.cc index ae0bece766..9f64c94cc0 100644 --- a/sli/gnureadline.cc +++ b/sli/gnureadline.cc @@ -57,7 +57,7 @@ GNUReadline::GNUReadlineFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); char* line_read = readline( sd->c_str() ); if ( line_read == nullptr ) { @@ -97,7 +97,7 @@ GNUReadline::GNUAddhistoryFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); i->EStack.pop(); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); add_history( sd->c_str() ); char* home = std::getenv( "HOME" ); std::string hist_file = std::string( home ) + std::string( "/.nest_history" ); diff --git a/sli/interpret.cc b/sli/interpret.cc index 9e7ff80d31..ffc4a46023 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -188,7 +188,7 @@ SLIInterpreter::initdictionaries() assert( DStack == nullptr ); DStack = new DictionaryStack(); - assert( DStack != nullptr ); + assert( DStack ); errordict = new Dictionary(); DictionaryDatum sysdict( new Dictionary() ); @@ -528,7 +528,7 @@ SLIInterpreter::addmodule( SLIModule* m ) if ( not( m->commandstring().empty() ) ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( baselookup( commandstring_name ).datum() ); - assert( ad != nullptr ); + assert( ad ); ad->push_back( new StringDatum( m->commandstring() ) ); } } @@ -543,7 +543,7 @@ SLIInterpreter::addlinkedusermodule( SLIModule* m ) if ( not( m->commandstring().empty() ) ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( baselookup( commandstring_name ).datum() ); - assert( ad != nullptr ); + assert( ad ); ad->push_back( new StringDatum( m->commandstring() ) ); } } @@ -596,7 +596,7 @@ SLIInterpreter::raiseerror( std::exception& err ) { Name caller = getcurrentname(); - assert( errordict != nullptr ); + assert( errordict ); errordict->insert( "command", EStack.top() ); // store the func/trie that caused the error. // SLIException provide addtional information @@ -623,7 +623,7 @@ SLIInterpreter::raiseerror( Name cmd, Name err ) // All error related symbols are now in their correct dictionary, // the error dictionary $errordict ( see Bug #4) - assert( errordict != nullptr ); + assert( errordict ); if ( errordict->lookup( newerror_name ) == baselookup( false_name ) ) { @@ -699,14 +699,14 @@ SLIInterpreter::print_error( Token cmd ) // Command information is only printed if the // command is of trietype - if ( command.datum() != nullptr ) + if ( command.datum() ) { if ( command->gettypename() == Name( "trietype" ) ) { msg << "\n\nCandidates for " << command << " are:\n"; TrieDatum* trie = dynamic_cast< TrieDatum* >( command.datum() ); - assert( trie != nullptr ); + assert( trie ); trie->get().info( msg ); } @@ -724,7 +724,7 @@ SLIInterpreter::print_error( Token cmd ) void SLIInterpreter::raiseagain() { - assert( errordict != nullptr ); + assert( errordict ); if ( errordict->known( commandname_name ) ) { @@ -931,12 +931,12 @@ Name SLIInterpreter::getcurrentname() const { FunctionDatum* func = dynamic_cast< FunctionDatum* >( EStack.top().datum() ); - if ( func != nullptr ) + if ( func ) { return ( func->getname() ); } TrieDatum* trie = dynamic_cast< TrieDatum* >( EStack.top().datum() ); - if ( trie != nullptr ) + if ( trie ) { return ( trie->getname() ); } @@ -1000,13 +1000,13 @@ SLIInterpreter::stack_backtrace( int n ) } FunctionDatum* fd = dynamic_cast< FunctionDatum* >( EStack.pick( p ).datum() ); - if ( fd != nullptr ) + if ( fd ) { fd->backtrace( this, p ); continue; } NameDatum* nd = dynamic_cast< NameDatum* >( EStack.pick( p ).datum() ); - if ( nd != nullptr ) + if ( nd ) { std::cerr << "While executing: "; nd->print( std::cerr ); @@ -1014,7 +1014,7 @@ SLIInterpreter::stack_backtrace( int n ) continue; } TrieDatum* td = dynamic_cast< TrieDatum* >( EStack.pick( p ).datum() ); - if ( td != nullptr ) + if ( td ) { std::cerr << "While executing: "; td->print( std::cerr ); diff --git a/sli/oosupport.cc b/sli/oosupport.cc index 79b17ce0d2..0099c6ba5f 100644 --- a/sli/oosupport.cc +++ b/sli/oosupport.cc @@ -55,13 +55,13 @@ OOSupportModule::CallMemberFunction::execute( SLIInterpreter* i ) const // call: dict key call -> unknown DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - assert( dict != nullptr ); + assert( dict ); LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - assert( key != nullptr ); + assert( key ); Token value = ( *dict )->lookup( *key ); - if ( value.datum() != nullptr ) + if ( value.datum() ) { Token nt( new NameDatum( *key ) ); i->DStack->push( *dict ); diff --git a/sli/parser.cc b/sli/parser.cc index 2a46c9c767..0313b69063 100644 --- a/sli/parser.cc +++ b/sli/parser.cc @@ -60,7 +60,7 @@ Parser::Parser( std::istream& is ) , ParseStack( 128 ) { init( is ); - assert( s != nullptr ); + assert( s ); } Parser::Parser() @@ -68,14 +68,14 @@ Parser::Parser() , ParseStack( 128 ) { init( std::cin ); - assert( s != nullptr ); + assert( s ); } bool Parser::operator()( Token& t ) { - assert( s != nullptr ); + assert( s ); Token pt; @@ -158,13 +158,13 @@ Parser::operator()( Token& t ) if ( pt->isoftype( SLIInterpreter::Arraytype ) ) { ArrayDatum* pa = dynamic_cast< ArrayDatum* >( pt.datum() ); - assert( pa != nullptr ); + assert( pa ); pa->push_back( t ); } else // now it must be a procedure { LitprocedureDatum* pp = dynamic_cast< LitprocedureDatum* >( pt.datum() ); - assert( pp != nullptr ); + assert( pp ); pp->set_executable(); pp->push_back( t ); } diff --git a/sli/parser.h b/sli/parser.h index b623ee2856..dc5d67aae9 100644 --- a/sli/parser.h +++ b/sli/parser.h @@ -86,7 +86,7 @@ class Parser void clear_context() { - if ( s != nullptr ) + if ( s ) { s->clear_context(); } diff --git a/sli/processes.cc b/sli/processes.cc index 7a80351b81..5bd9aa9637 100644 --- a/sli/processes.cc +++ b/sli/processes.cc @@ -100,7 +100,7 @@ const std::string Processes::systemerror( SLIInterpreter* i ) { Token errordict_t( i->baselookup( i->errordict_name ) ); - assert( errordict_t.datum() != nullptr ); + assert( errordict_t.datum() ); DictionaryDatum errordict_d = *dynamic_cast< DictionaryDatum* >( errordict_t.datum() ); std::string ErrorMessage( std::strerror( errno ) ); @@ -121,7 +121,7 @@ Processes::fd( std::istream* s ) else { ifdstream* fs = dynamic_cast< ifdstream* >( s ); - assert( fs != nullptr ); + assert( fs ); return fs->rdbuf()->fd(); } } @@ -140,7 +140,7 @@ Processes::fd( std::ostream* s ) else { ofdstream* fs = dynamic_cast< ofdstream* >( s ); - assert( fs != nullptr ); + assert( fs ); return fs->rdbuf()->fd(); } } @@ -196,7 +196,7 @@ Processes::init( SLIInterpreter* i ) // create variables "sys_errname" and "sys_errno" // and all needed errornumbers in errordict Token errordict_t( i->baselookup( i->errordict_name ) ); - assert( errordict_t.datum() != nullptr ); + assert( errordict_t.datum() ); DictionaryDatum errordict_d = *dynamic_cast< DictionaryDatum* >( errordict_t.datum() ); errordict_d->insert( sys_errname, new LiteralDatum( "" ) ); @@ -338,7 +338,7 @@ Processes::Sysexec_aFunction::execute( SLIInterpreter* i ) const // this is an array of tokens (to names) ArrayDatum* array = dynamic_cast< ArrayDatum* >( array_token.datum() ); - assert( array != nullptr ); + assert( array ); assert( array->size() > 0 ); // need at least the commandname @@ -355,7 +355,7 @@ Processes::Sysexec_aFunction::execute( SLIInterpreter* i ) const for ( unsigned int j = 0; j < array->size(); j++ ) // forall in array { StringDatum* nd = dynamic_cast< StringDatum* >( ( *array )[ j ].datum() ); - assert( nd != nullptr ); + assert( nd ); // StringDatum is derived from class string. argv[ j ] = const_cast< char* >( nd->c_str() ); } @@ -383,10 +383,10 @@ Processes::WaitPIDFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IntegerDatum* pidin_d = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( pidin_d != nullptr ); + assert( pidin_d ); BoolDatum* nohangflag_d = dynamic_cast< BoolDatum* >( i->OStack.top().datum() ); - assert( nohangflag_d != nullptr ); + assert( nohangflag_d ); // call waitpid() int stat_value; @@ -455,10 +455,10 @@ Processes::KillFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IntegerDatum* pid_d = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( pid_d != nullptr ); + assert( pid_d ); IntegerDatum* signal_d = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( signal_d != nullptr ); + assert( signal_d ); // call kill() int result = kill( pid_d->get(), signal_d->get() ); @@ -510,9 +510,9 @@ Processes::Dup2_is_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); IstreamDatum* s_d2 = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != nullptr ); + assert( s_d2 ); // call dup2(); // int result = dup2( fd(s_d1->get()) , fd(s_d2->get()) );//using get() on a @@ -544,9 +544,9 @@ Processes::Dup2_os_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); OstreamDatum* s_d2 = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != nullptr ); + assert( s_d2 ); // call dup2(); // for comments on LockPTRs see Dup2_is_isFunction::execute @@ -572,9 +572,9 @@ Processes::Dup2_is_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); OstreamDatum* s_d2 = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != nullptr ); + assert( s_d2 ); // call dup2(); // int result = dup2( fd(s_d1->get()) , fd(s_d2->get()) );//using get() on a @@ -606,9 +606,9 @@ Processes::Dup2_os_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); IstreamDatum* s_d2 = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( s_d2 != nullptr ); + assert( s_d2 ); // call dup2(); // for comments on LockPTRs see Dup2_is_isFunction::execute @@ -633,7 +633,7 @@ Processes::AvailableFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - assert( istreamdatum != nullptr ); + assert( istreamdatum ); assert( istreamdatum->valid() ); if ( not( **istreamdatum ).good() ) @@ -797,7 +797,7 @@ Processes::MkfifoFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: StringDatum* s_d = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s_d != nullptr ); + assert( s_d ); // call mkfifo(); mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; // Try to give all permissions, @@ -841,11 +841,11 @@ Processes::SetNonblockFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 2 ); // setNONBLOCK takes 2 arguments IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( istreamdatum != nullptr ); + assert( istreamdatum ); assert( istreamdatum->valid() ); BoolDatum* newflag_d = dynamic_cast< BoolDatum* >( i->OStack.top().datum() ); - assert( newflag_d != nullptr ); + assert( newflag_d ); // get filedescriptor: // istreamdatum is a pointer to a LockPTR @@ -907,7 +907,7 @@ Processes::Isatty_osFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: OstreamDatum* s_d1 = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); int fd = Processes::fd( **s_d1 ); // Get FileDescriptor @@ -932,7 +932,7 @@ Processes::Isatty_isFunction::execute( SLIInterpreter* i ) const // Read arguments from operand Stack, but leave tokens on stack: IstreamDatum* s_d1 = dynamic_cast< IstreamDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s_d1 != nullptr ); + assert( s_d1 ); int fd = Processes::fd( **s_d1 ); // Get FileDescriptor diff --git a/sli/sli_io.cc b/sli/sli_io.cc index 355bdaa9b6..e61b03a0bc 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -292,7 +292,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const return; } - if ( out != nullptr ) + if ( out ) { i->OStack.pop( 2 ); if ( out->good() ) @@ -416,10 +416,10 @@ StrSStreamFunction::execute( SLIInterpreter* i ) const #else std::ostrstream* out = dynamic_cast< std::ostrstream* >( ostreamdatum->get() ); #endif - assert( out != nullptr ); + assert( out ); ostreamdatum->unlock(); - if ( out != nullptr ) + if ( out ) { if ( out->good() ) { @@ -781,7 +781,7 @@ CloseistreamFunction::execute( SLIInterpreter* i ) const // the datum conatains &std::cin !! ifdstream* ifs = dynamic_cast< ifdstream* >( istreamdatum->get() ); istreamdatum->unlock(); - if ( ifs != nullptr ) + if ( ifs ) { ifs->close(); // iostreamhandle->destroy(); @@ -829,7 +829,7 @@ CloseostreamFunction::execute( SLIInterpreter* i ) const ofdstream* ofs = dynamic_cast< ofdstream* >( ostreamdatum->get() ); ostreamdatum->unlock(); - if ( ofs != nullptr ) + if ( ofs ) { ofs->close(); i->OStack.pop(); @@ -1720,7 +1720,7 @@ Cvx_fFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); IstreamDatum* sd = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( sd != nullptr ) + if ( sd ) { Token handle_token( new XIstreamDatum( *sd ) ); i->OStack.pop(); diff --git a/sli/sliactions.cc b/sli/sliactions.cc index 1fb5321037..e4fc75d405 100644 --- a/sli/sliactions.cc +++ b/sli/sliactions.cc @@ -89,7 +89,7 @@ FunctiontypeFunction::execute( SLIInterpreter* i ) const if ( i->step_mode() ) { std::cerr << "Calling builtin function: "; - if ( fd != nullptr ) + if ( fd ) { fd->pprint( std::cerr ); } diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 43eeb7201c..547fb6f6ac 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -67,11 +67,11 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->size() == 1 ) // Construct an array of elements 1 ... N { IntegerDatum* nd = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); - if ( nd != nullptr ) + if ( nd ) { long n = nd->get(); ad->erase(); @@ -106,7 +106,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) + if ( ( n1d ) && ( n2d ) ) { long n = 1 + n2d->get() - n1d->get(); @@ -130,7 +130,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) + if ( ( n1d ) && ( n2d ) ) { long n = 1 + static_cast< long >( n2d->get() - n1d->get() ); @@ -161,7 +161,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) + if ( ( n1d ) && ( n2d ) && ( n3d ) ) { long di = n3d->get(); long start = n1d->get(); @@ -192,7 +192,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) + if ( ( n1d ) && ( n2d ) && ( n3d ) ) { double di = n3d->get(); double start = n1d->get(); @@ -240,11 +240,11 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->size() == 1 ) // Construct an array of elements 1 ... N { IntegerDatum* nd = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); - if ( nd != nullptr ) + if ( nd ) { long n = nd->get(); if ( n < 0 ) @@ -286,7 +286,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) + if ( ( n1d ) && ( n2d ) ) { const long start = n1d->get(); const long stop = n2d->get(); @@ -310,7 +310,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) ) + if ( ( n1d ) && ( n2d ) ) { double start = n1d->get(); double stop = n2d->get(); @@ -338,7 +338,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) + if ( ( n1d ) && ( n2d ) && ( n3d ) ) { long di = n3d->get(); long start = n1d->get(); @@ -372,7 +372,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d != nullptr ) && ( n2d != nullptr ) && ( n3d != nullptr ) ) + if ( ( n1d ) && ( n2d ) && ( n3d ) ) { double di = n3d->get(); double start = n1d->get(); @@ -421,7 +421,7 @@ SLIArrayModule::ReverseFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); ad->reverse(); i->EStack.pop(); } @@ -447,7 +447,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); ArrayDatum* ta = new ArrayDatum(); Token at( ta ); @@ -457,7 +457,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token const* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != nullptr ) + if ( ad1 ) { size += ad1->size(); } @@ -480,7 +480,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != nullptr ) + if ( ad1 ) { if ( ad1->references() > 1 ) { @@ -508,7 +508,7 @@ SLIArrayModule::FlattenFunction::execute( SLIInterpreter* i ) const for ( Token const* t = ad->begin(); t != ad->end(); ++t ) { ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( t->datum() ); - if ( ad1 != nullptr ) + if ( ad1 ) { for ( Token const* t1 = ad1->begin(); t1 != ad1->end(); ++t1 ) { @@ -648,10 +648,10 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* sd = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); ArrayDatum* hd = dynamic_cast< ArrayDatum* >( sd->begin()->datum() ); - assert( hd != nullptr ); + assert( hd ); // size of source first level size_t m = sd->size(); @@ -664,7 +664,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const ArrayDatum* td = new ArrayDatum(); - assert( td != nullptr ); + assert( td ); Token tt( td ); @@ -675,7 +675,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const for ( size_t j = 0; j < n; j++ ) { hd = new ArrayDatum(); - assert( td != nullptr ); + assert( td ); hd->reserve( m ); @@ -687,7 +687,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const hd = dynamic_cast< ArrayDatum* >( sr->datum() ); // raiseerror instead - assert( hd != nullptr ); + assert( hd ); Token* sc; Token* tr; @@ -698,7 +698,7 @@ SLIArrayModule::TransposeFunction::execute( SLIInterpreter* i ) const ArrayDatum* trd = dynamic_cast< ArrayDatum* >( tr->datum() ); // raiseerror instead - assert( trd != nullptr ); + assert( trd ); trd->push_back( *sc ); } @@ -719,11 +719,11 @@ SLIArrayModule::PartitionFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 2 ); IntegerDatum* dd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( dd != nullptr ); + assert( dd ); IntegerDatum* nd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( nd != nullptr ); + assert( nd ); ArrayDatum* source = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); - assert( source != nullptr ); + assert( source ); ArrayDatum* target = new ArrayDatum; long n = nd->get(); @@ -805,7 +805,7 @@ SLIArrayModule::ArrayloadFunction::execute( SLIInterpreter* i ) const at.move( i->OStack.top() ); i->OStack.pop(); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( at.datum() ); - assert( ad != nullptr ); + assert( ad ); i->EStack.pop(); int arraysize = ad->size(); i->OStack.reserve_token( arraysize ); @@ -861,7 +861,7 @@ SLIArrayModule::ArraystoreFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != nullptr ); + assert( id ); long n = id->get(); if ( n >= 0 ) @@ -938,13 +938,13 @@ void SLIArrayModule::IMapFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != nullptr ); + assert( id ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != nullptr ); + assert( pd ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1036,7 +1036,7 @@ SLIArrayModule::IMapFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != nullptr ) + if ( proc ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1058,13 +1058,13 @@ void SLIArrayModule::IMap_ivFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != nullptr ); + assert( id ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != nullptr ); + assert( pd ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1174,7 +1174,7 @@ SLIArrayModule::IMap_ivFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != nullptr ) + if ( proc ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1197,13 +1197,13 @@ void SLIArrayModule::IMap_dvFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != nullptr ); + assert( id ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != nullptr ); + assert( pd ); std::cerr << "During Map at iteration " << count->get() << "." << std::endl; @@ -1309,7 +1309,7 @@ SLIArrayModule::IMap_dvFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != nullptr ) + if ( proc ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1388,7 +1388,7 @@ SLIArrayModule::MapFunction::execute( SLIInterpreter* i ) const { i->EStack.pop(); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != nullptr ); + assert( proc ); if ( proc->size() == 0 ) { @@ -1426,7 +1426,7 @@ SLIArrayModule::ValidFunction::execute( SLIInterpreter* i ) const { assert( i->OStack.load() > 0 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); i->OStack.push( ad->valid() ); i->EStack.pop(); @@ -1436,13 +1436,13 @@ void SLIArrayModule::IMapIndexedFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != nullptr ); + assert( id ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != nullptr ); + assert( pd ); std::cerr << "During MapIndexed at iteration " << count->get() << "." << std::endl; @@ -1538,7 +1538,7 @@ SLIArrayModule::IMapIndexedFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( proc != nullptr ) + if ( proc ) { proc->list( std::cerr, " ", pos ); std::cerr << std::endl; @@ -1563,7 +1563,7 @@ SLIArrayModule::MapIndexedFunction::execute( SLIInterpreter* i ) const { i->EStack.pop(); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != nullptr ); + assert( proc ); if ( proc->size() == 0 ) { @@ -1588,13 +1588,13 @@ void SLIArrayModule::IMapThreadFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( id != nullptr ); + assert( id ); IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( pd != nullptr ); + assert( pd ); std::cerr << "During MapThread at iteration " << count->get() << "." << std::endl; @@ -1710,7 +1710,7 @@ SLIArrayModule::IMapThreadFunction::execute( SLIInterpreter* i ) const char cmd = i->debug_commandline( i->EStack.top() ); if ( cmd == 'l' ) // List the procedure { - if ( procd != nullptr ) + if ( procd ) { procd->list( std::cerr, " ", proccount ); std::cerr << std::endl; @@ -1756,7 +1756,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const { assert( i->OStack.load() >= 2 ); ProcedureDatum* proc = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( proc != nullptr ); + assert( proc ); if ( proc->size() == 0 ) { @@ -1767,7 +1767,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const } ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->size() > 0 ) { @@ -1853,7 +1853,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const for ( Token* t = pos->begin(); t != pos->end(); ++t ) { - assert( t != nullptr ); + assert( t ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( t->datum() ); if ( idx == nullptr ) { @@ -4006,7 +4006,7 @@ void SLIArrayModule::Iforall_ivFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forall (IntVector) at iteration " << count->get() << "." << std::endl; } @@ -4082,7 +4082,7 @@ void SLIArrayModule::Iforall_dvFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forall (DoubleVector) at iteration " << count->get() << "." << std::endl; } diff --git a/sli/slibuiltins.cc b/sli/slibuiltins.cc index 92ed2c219b..77307a1f94 100644 --- a/sli/slibuiltins.cc +++ b/sli/slibuiltins.cc @@ -46,7 +46,7 @@ IsetcallbackFunction::execute( SLIInterpreter* i ) const // move the hopefully present callback action // into the interpreters callback token. i->EStack.pop(); - assert( dynamic_cast< CallbackDatum* >( i->EStack.top().datum() ) != nullptr ); + assert( dynamic_cast< CallbackDatum* >( i->EStack.top().datum() ) ); i->EStack.pop_move( i->ct ); } @@ -54,10 +54,10 @@ void IiterateFunction::backtrace( SLIInterpreter* i, int p ) const { ProcedureDatum const* pd = dynamic_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != nullptr ); + assert( pd ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != nullptr ); + assert( id ); std::cerr << "In procedure:" << std::endl; @@ -133,10 +133,10 @@ void IloopFunction::backtrace( SLIInterpreter* i, int p ) const { ProcedureDatum const* pd = dynamic_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != nullptr ); + assert( pd ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != nullptr ); + assert( id ); std::cerr << "During loop:" << std::endl; @@ -185,13 +185,13 @@ void IrepeatFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != nullptr ); + assert( pd ); IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != nullptr ); + assert( id ); std::cerr << "During repeat with " << count->get() << " iterations remaining." << std::endl; @@ -252,11 +252,11 @@ void IforFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != nullptr ); + assert( count ); ProcedureDatum const* pd = static_cast< ProcedureDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( pd != nullptr ); + assert( pd ); IntegerDatum* id = static_cast< IntegerDatum* >( i->EStack.pick( p + 1 ).datum() ); - assert( id != nullptr ); + assert( id ); std::cerr << "During for at iterator value " << count->get() << "." << std::endl; @@ -315,7 +315,7 @@ void IforallarrayFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 3 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forall (array) at iteration " << count->get() << "." << std::endl; } @@ -353,7 +353,7 @@ void IforallindexedarrayFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forallindexed (array) at iteration " << count->get() - 1 << "." << std::endl; } @@ -362,7 +362,7 @@ void IforallindexedstringFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forallindexed (string) at iteration " << count->get() - 1 << "." << std::endl; } @@ -405,7 +405,7 @@ void IforallstringFunction::backtrace( SLIInterpreter* i, int p ) const { IntegerDatum* count = static_cast< IntegerDatum* >( i->EStack.pick( p + 2 ).datum() ); - assert( count != nullptr ); + assert( count ); std::cerr << "During forall (string) at iteration " << count->get() - 1 << "." << std::endl; } diff --git a/sli/slidata.cc b/sli/slidata.cc index 92d14393a5..c7ee414e87 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -62,9 +62,9 @@ Get_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != nullptr ); + assert( idx ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -154,9 +154,9 @@ Get_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != nullptr ); + assert( idx ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -179,9 +179,9 @@ Get_lpFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != nullptr ); + assert( idx ); LitprocedureDatum* obj = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) { @@ -204,7 +204,7 @@ Append_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); obj->push_back_move( i->OStack.top() ); @@ -219,7 +219,7 @@ Append_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); obj->push_back_move( i->OStack.top() ); @@ -251,7 +251,7 @@ Append_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != nullptr && id != nullptr ); + assert( sd && id ); ( *sd ) += static_cast< char >( id->get() ); @@ -307,7 +307,7 @@ Join_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != nullptr && a2 != nullptr ); + assert( a1 && a2 ); a1->append_move( *a2 ); @@ -325,7 +325,7 @@ Join_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* a1 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); ProcedureDatum* a2 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != nullptr && a2 != nullptr ); + assert( a1 && a2 ); a1->append_move( *a2 ); @@ -355,7 +355,7 @@ Insert_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && s2 != nullptr ); + assert( s1 && id && s2 ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -391,7 +391,7 @@ InsertElement_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && c != nullptr ); + assert( s1 && id && c ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -430,7 +430,7 @@ Prepend_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && c != nullptr ); + assert( s1 && c ); s1->insert( ( size_t ) 0, 1, static_cast< char >( c->get() ) ); @@ -447,7 +447,7 @@ Insert_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 != nullptr && id != nullptr && a2 != nullptr ); + assert( a1 && id && a2 ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) { @@ -470,7 +470,7 @@ InsertElement_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != nullptr && id != nullptr ); + assert( a1 && id ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) { @@ -494,7 +494,7 @@ Prepend_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != nullptr ); + assert( a1 ); a1->insert_move( 0, i->OStack.top() ); @@ -511,7 +511,7 @@ Prepend_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* a1 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 != nullptr ); + assert( a1 ); a1->insert_move( 0, i->OStack.top() ); @@ -544,7 +544,7 @@ Replace_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && n != nullptr && s2 != nullptr ); + assert( s1 && id && n && s2 ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -576,7 +576,7 @@ Replace_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && n != nullptr && s2 != nullptr ); + assert( s1 && id && n && s2 ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -621,7 +621,7 @@ Erase_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && n != nullptr ); + assert( s1 && id && n ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -652,7 +652,7 @@ Erase_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && n != nullptr ); + assert( s1 && id && n ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -683,7 +683,7 @@ Erase_pFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && n != nullptr ); + assert( s1 && id && n ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -715,7 +715,7 @@ Put_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && id != nullptr && cd != nullptr ); + assert( s1 && id && cd ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { @@ -739,7 +739,7 @@ Put_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -763,7 +763,7 @@ Put_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* ad = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -787,7 +787,7 @@ Put_lpFunction::execute( SLIInterpreter* i ) const LitprocedureDatum* ad = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) { @@ -819,7 +819,7 @@ Length_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->length() ) ); @@ -845,7 +845,7 @@ Length_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->size() ) ); @@ -871,7 +871,7 @@ Length_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* s = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->size() ) ); @@ -901,7 +901,7 @@ Length_lpFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); LitprocedureDatum* s = dynamic_cast< LitprocedureDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->size() ) ); @@ -931,7 +931,7 @@ Capacity_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->capacity() ) ); @@ -958,7 +958,7 @@ Size_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* s = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->size() ) ); @@ -983,7 +983,7 @@ Reserve_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1018,7 +1018,7 @@ Resize_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1040,7 +1040,7 @@ Empty_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->empty() ) { @@ -1061,7 +1061,7 @@ References_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); Token t( new IntegerDatum( ad->references() ) ); @@ -1084,7 +1084,7 @@ Shrink_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->shrink() ) { @@ -1104,7 +1104,7 @@ Capacity_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->capacity() ) ); @@ -1119,7 +1119,7 @@ Size_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* s = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( s != nullptr ); + assert( s ); Token t( new IntegerDatum( s->size() ) ); @@ -1135,7 +1135,7 @@ Reserve_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( id->get() >= 0 ) { @@ -1158,7 +1158,7 @@ Resize_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad != nullptr && id != nullptr ); + assert( ad && id ); if ( id->get() >= 0 ) { @@ -1182,7 +1182,7 @@ Empty_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); if ( ad->empty() ) { @@ -1229,7 +1229,7 @@ Getinterval_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != nullptr && id != nullptr && cd != nullptr ); + assert( sd && id && cd ); if ( cd->get() >= 0 ) { @@ -1261,7 +1261,7 @@ Getinterval_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* sd = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd != nullptr && id != nullptr && cd != nullptr ); + assert( sd && id && cd ); if ( cd->get() >= 0 ) { @@ -1293,7 +1293,7 @@ Cvx_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new ProcedureDatum( *obj ) ); t->set_executable(); i->OStack.top().swap( t ); @@ -1305,7 +1305,7 @@ Cvlit_nFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); NameDatum* obj = dynamic_cast< NameDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new LiteralDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1317,7 +1317,7 @@ Cvn_lFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); LiteralDatum* obj = dynamic_cast< LiteralDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new NameDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1329,7 +1329,7 @@ Cvn_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new NameDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1341,7 +1341,7 @@ Cvlit_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new ArrayDatum( *obj ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1356,7 +1356,7 @@ Cvlp_pFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); ProcedureDatum* obj = dynamic_cast< ProcedureDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new LitprocedureDatum( *obj ) ); t->set_executable(); i->OStack.top().swap( t ); @@ -1370,7 +1370,7 @@ Cvi_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new IntegerDatum( std::atoi( obj->c_str() ) ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1383,7 +1383,7 @@ Cvd_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( obj != nullptr ); + assert( obj ); Token t( new DoubleDatum( std::atof( obj->c_str() ) ) ); i->OStack.top().swap( t ); i->EStack.pop(); @@ -1397,10 +1397,10 @@ Get_sFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( idx != nullptr ); + assert( idx ); StringDatum* obj = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); - assert( obj != nullptr ); + assert( obj ); if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) @@ -1439,7 +1439,7 @@ Search_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && s2 != nullptr ); + assert( s1 && s2 ); size_t p = s1->find( *s2 ); @@ -1474,7 +1474,7 @@ Search_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* s1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 != nullptr && s2 != nullptr ); + assert( s1 && s2 ); Token* p = std::search( s1->begin(), s1->end(), s2->begin(), s2->end() ); diff --git a/sli/slidict.cc b/sli/slidict.cc index 1facbd6541..dfa1bc07ce 100644 --- a/sli/slidict.cc +++ b/sli/slidict.cc @@ -105,10 +105,10 @@ DictputFunction::execute( SLIInterpreter* i ) const { // call: dict key val DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 2 ).datum() ); - if ( dict != nullptr ) + if ( dict ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 1 ).datum() ); - if ( key != nullptr ) + if ( key ) { ( *dict )->insert_move( *key, i->OStack.top() ); #ifdef DICTSTACK_CACHE @@ -172,10 +172,10 @@ DictgetFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() >= 2 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dict != nullptr ) + if ( dict ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - if ( key != nullptr ) + if ( key ) { Token value = ( *dict )->lookup2( *key ); i->EStack.pop(); // never forget me @@ -235,8 +235,8 @@ DictinfoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); - assert( outd != nullptr ); + assert( dict ); + assert( outd ); i->EStack.pop(); ( *dict )->info( **outd ); i->OStack.pop( 2 ); @@ -263,7 +263,7 @@ Length_dFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); i->EStack.pop(); Token st( new IntegerDatum( ( *dict )->size() ) ); i->OStack.pop(); @@ -278,7 +278,7 @@ Empty_DFunction::execute( SLIInterpreter* i ) const DictionaryDatum const* const dd = dynamic_cast< DictionaryDatum const* const >( i->OStack.top().datum() ); - assert( dd != nullptr ); + assert( dd ); i->OStack.push_by_pointer( new BoolDatum( ( *dd )->empty() ) ); @@ -397,7 +397,7 @@ DicttopinfoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( outd != nullptr ); + assert( outd ); i->EStack.pop(); i->DStack->top_info( **outd ); i->OStack.pop(); @@ -426,7 +426,7 @@ WhoFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 0 ); OstreamDatum* outd = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - assert( outd != nullptr ); + assert( outd ); i->EStack.pop(); i->DStack->info( **outd ); i->OStack.pop(); @@ -455,7 +455,7 @@ DictbeginFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() > 0 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - if ( dict != nullptr ) + if ( dict ) { i->EStack.pop(); i->DStack->push( *dict ); @@ -550,10 +550,10 @@ UndefFunction::execute( SLIInterpreter* i ) const if ( i->OStack.load() > 1 ) { DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dict != nullptr ) + if ( dict ) { LiteralDatum* key = dynamic_cast< LiteralDatum* >( i->OStack.pick( 0 ).datum() ); - if ( key != nullptr ) + if ( key ) { i->EStack.pop(); #ifdef DICTSTACK_CACHE @@ -722,7 +722,7 @@ CleardictFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); #ifdef DICTSTACK_CACHE if ( ( *dict )->is_on_dictstack() ) { @@ -762,7 +762,7 @@ ClonedictFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); i->OStack.push( DictionaryDatum( new Dictionary( *( *dict ) ) ) ); i->EStack.pop(); // never forget me @@ -831,7 +831,7 @@ Cva_dFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); ArrayDatum* ad = new ArrayDatum(); ad->reserve( ( *dict )->size() * 2 ); @@ -882,7 +882,7 @@ KeysFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); ArrayDatum* ad = new ArrayDatum(); for ( TokenMap::const_iterator t = ( *dict )->begin(); t != ( *dict )->end(); ++t ) @@ -932,7 +932,7 @@ ValuesFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); assert( i->OStack.load() > 0 ); DictionaryDatum* dict = dynamic_cast< DictionaryDatum* >( i->OStack.top().datum() ); - assert( dict != nullptr ); + assert( dict ); ArrayDatum* ad = new ArrayDatum(); for ( TokenMap::const_iterator t = ( *dict )->begin(); t != ( *dict )->end(); ++t ) @@ -948,7 +948,7 @@ RestoredstackFunction::execute( SLIInterpreter* i ) const { i->assert_stack_load( 1 ); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); TokenArray ta = *ad; DictionaryStack* olddstack = i->DStack; // copy current dstack i->DStack = new DictionaryStack; diff --git a/sli/slimath.cc b/sli/slimath.cc index dcf85cce68..673113e995 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -47,7 +47,7 @@ IntegerFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); DoubleDatum* op = dynamic_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op != nullptr ) + if ( op ) { Token res( new IntegerDatum( op->get() ) ); i->OStack.top().swap( res ); @@ -61,7 +61,7 @@ DoubleFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); IntegerDatum* op = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op != nullptr ) + if ( op ) { Token res( new DoubleDatum( op->get() ) ); @@ -1119,7 +1119,7 @@ OrFunction::execute( SLIInterpreter* i ) const BoolDatum* op1 = static_cast< BoolDatum* >( i->OStack.pick( 1 ).datum() ); BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); op1->get() = ( op1->get() or op2->get() ); @@ -1261,7 +1261,7 @@ Gt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() > op2->get(); @@ -1278,7 +1278,7 @@ Gt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() > op2->get(); @@ -1296,7 +1296,7 @@ Gt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = *op1 > *op2; @@ -1323,7 +1323,7 @@ Lt_idFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() < op2->get(); @@ -1340,7 +1340,7 @@ Lt_diFunction::execute( SLIInterpreter* i ) const IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() < op2->get(); @@ -1358,7 +1358,7 @@ Lt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() < op2->get(); @@ -1375,7 +1375,7 @@ Lt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = op1->get() < op2->get(); @@ -1393,7 +1393,7 @@ Lt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 != nullptr && op2 != nullptr ); + assert( op1 && op2 ); bool result = *op1 < *op2; @@ -1432,7 +1432,7 @@ UnitStep_iFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); IntegerDatum* x = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( x != nullptr ); + assert( x ); bool result = x->get() >= 0; @@ -1456,14 +1456,14 @@ UnitStep_daFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); TokenArray* a = dynamic_cast< TokenArray* >( i->OStack.pick( 0 ).datum() ); - assert( a != nullptr ); + assert( a ); bool result = true; for ( size_t j = 0; j < a->size(); ++j ) { DoubleDatum* x = static_cast< DoubleDatum* >( ( *a )[ j ].datum() ); - assert( x != nullptr ); + assert( x ); if ( x->get() < 0.0 ) { result = false; @@ -1490,14 +1490,14 @@ UnitStep_iaFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() >= 1 ); TokenArray* a = dynamic_cast< TokenArray* >( i->OStack.pick( 0 ).datum() ); - assert( a != nullptr ); + assert( a ); bool result = true; for ( size_t j = 0; j < a->size(); ++j ) { IntegerDatum* x = static_cast< IntegerDatum* >( ( *a )[ j ].datum() ); - assert( x != nullptr ); + assert( x ); if ( x->get() < 0 ) { result = false; diff --git a/sli/sliregexp.cc b/sli/sliregexp.cc index 3dffe39831..f12619d7bd 100644 --- a/sli/sliregexp.cc +++ b/sli/sliregexp.cc @@ -117,8 +117,8 @@ RegexpModule::RegcompFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); - assert( sd != nullptr ); - assert( id != nullptr ); + assert( sd ); + assert( id ); Regex* MyRegex = new Regex; @@ -147,8 +147,8 @@ RegexpModule::RegerrorFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); RegexDatum* rd = dynamic_cast< RegexDatum* >( i->OStack.pick( 1 ).datum() ); - assert( rd != nullptr ); - assert( id != nullptr ); + assert( rd ); + assert( id ); char* error_buffer = new char[ 256 ]; regerror( id->get(), rd->get()->get(), error_buffer, 256 ); @@ -178,16 +178,16 @@ RegexpModule::RegexecFunction::execute( SLIInterpreter* i ) const IntegerDatum* sized = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* eflagsd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( rd != nullptr ); - assert( sd != nullptr ); - assert( sized != nullptr ); - assert( eflagsd != nullptr ); + assert( rd ); + assert( sd ); + assert( sized ); + assert( eflagsd ); int size = sized->get(); regmatch_t* pm = new regmatch_t[ size ]; Regex* r = rd->get(); - assert( r != nullptr ); + assert( r ); rd->unlock(); int e = regexec( r->get(), sd->c_str(), size, pm, eflagsd->get() ); diff --git a/sli/slistack.cc b/sli/slistack.cc index d9a0f9e906..eadf5183da 100644 --- a/sli/slistack.cc +++ b/sli/slistack.cc @@ -75,7 +75,7 @@ NpopFunction::execute( SLIInterpreter* i ) const } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != nullptr ); + assert( id ); size_t n = id->get(); if ( n < i->OStack.load() ) { @@ -166,7 +166,7 @@ IndexFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != nullptr ); + assert( id ); size_t pos = id->get(); if ( pos + 1 < i->OStack.load() ) @@ -201,7 +201,7 @@ CopyFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - assert( id != nullptr ); + assert( id ); size_t n = id->get(); if ( n < i->OStack.load() ) { @@ -404,7 +404,7 @@ RestoreestackFunction::execute( SLIInterpreter* i ) const } ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); TokenArray ta = *ad; i->OStack.pop(); i->EStack = ta; @@ -434,7 +434,7 @@ RestoreostackFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - assert( ad != nullptr ); + assert( ad ); TokenArray ta = *ad; i->OStack = ta; } diff --git a/sli/slistartup.cc b/sli/slistartup.cc index 2ce4fe66cf..cb92f0d9a6 100644 --- a/sli/slistartup.cc +++ b/sli/slistartup.cc @@ -116,10 +116,10 @@ SLIStartup::GetenvFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - assert( sd != nullptr ); + assert( sd ); const char* s = ::getenv( sd->c_str() ); i->OStack.pop(); - if ( s != nullptr ) + if ( s ) { Token t( new StringDatum( s ) ); i->OStack.push_move( t ); diff --git a/sli/slitypecheck.cc b/sli/slitypecheck.cc index 6d9657f682..0cb0e41c94 100644 --- a/sli/slitypecheck.cc +++ b/sli/slitypecheck.cc @@ -205,7 +205,7 @@ Cva_tFunction::execute( SLIInterpreter* i ) const i->OStack.pop(); TrieDatum* trie = dynamic_cast< TrieDatum* >( trietoken.datum() ); - assert( trie != nullptr ); + assert( trie ); Name triename( trie->getname() ); i->OStack.push( LiteralDatum( triename ) ); @@ -222,13 +222,13 @@ TrieInfoFunction::execute( SLIInterpreter* i ) const i->EStack.pop(); OstreamDatum* osd = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - assert( osd != nullptr ); + assert( osd ); Token trietoken; trietoken.move( i->OStack.top() ); TrieDatum* trie = dynamic_cast< TrieDatum* >( trietoken.datum() ); - assert( trie != nullptr ); + assert( trie ); trie->get().info( **osd ); i->OStack.pop( 2 ); @@ -305,12 +305,12 @@ Cvt_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.size() > 1 ); LiteralDatum* name = dynamic_cast< LiteralDatum* >( i->OStack.pick( 1 ).datum() ); - assert( name != nullptr ); + assert( name ); ArrayDatum* arr = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( arr != nullptr ); + assert( arr ); TrieDatum* trie = new TrieDatum( *name, *arr ); - assert( trie != nullptr ); + assert( trie ); Token tmp( trie ); i->OStack.pop(); i->OStack.push_move( tmp ); diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index 775df49526..c7e33c3721 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -53,7 +53,7 @@ TokenArrayObj::TokenArrayObj( const TokenArrayObj& a ) , alloc_block_size( ARRAY_ALLOC_SIZE ) , refs_( 1 ) { - if ( a.p != nullptr ) + if ( a.p ) { resize( a.size(), a.alloc_block_size, Token() ); Token* from = a.p; @@ -102,7 +102,7 @@ TokenArrayObj::allocate( size_t new_s, size_t new_c, size_t new_a, const Token& end_of_free_storage = h + new_c; // [,) convention begin_of_free_storage = h + new_s; - if ( p != nullptr ) + if ( p ) { size_t min_l; @@ -170,7 +170,7 @@ TokenArrayObj::operator=( const TokenArrayObj& a ) else { - if ( p != nullptr ) + if ( p ) { delete[] p; p = nullptr; diff --git a/sli/token.h b/sli/token.h index 912ed355eb..6a795b594f 100644 --- a/sli/token.h +++ b/sli/token.h @@ -312,7 +312,7 @@ class Token void assign_by_pointer( Datum* rhs ) { - assert( rhs != nullptr ); + assert( rhs ); rhs->addReference(); if ( p ) { @@ -341,7 +341,7 @@ class Token bool contains( const Datum& d ) const { - return ( p != nullptr ) and p->equals( &d ); + return ( p ) and p->equals( &d ); } bool diff --git a/sli/tokenarray.cc b/sli/tokenarray.cc index 3cd5b4a154..34f99aed59 100644 --- a/sli/tokenarray.cc +++ b/sli/tokenarray.cc @@ -43,7 +43,7 @@ TokenArray::operator=( const TokenArray& a ) TokenArray::TokenArray( const std::vector< long >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != nullptr ); + assert( data ); for ( size_t i = 0; i < a.size(); ++i ) { Token idt( new IntegerDatum( a[ i ] ) ); @@ -54,7 +54,7 @@ TokenArray::TokenArray( const std::vector< long >& a ) TokenArray::TokenArray( const std::vector< size_t >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != nullptr ); + assert( data ); for ( size_t i = 0; i < a.size(); ++i ) { Token idt( new IntegerDatum( a[ i ] ) ); @@ -65,7 +65,7 @@ TokenArray::TokenArray( const std::vector< size_t >& a ) TokenArray::TokenArray( const std::vector< double >& a ) : data( new TokenArrayObj( a.size(), Token(), 0 ) ) { - assert( data != nullptr ); + assert( data ); for ( size_t i = 0; i < a.size(); ++i ) { Token ddt( new DoubleDatum( a[ i ] ) ); diff --git a/sli/tokenutils.cc b/sli/tokenutils.cc index 0ed85bed7b..eff557a6b2 100644 --- a/sli/tokenutils.cc +++ b/sli/tokenutils.cc @@ -155,7 +155,7 @@ getValue< std::string >( const Token& t ) { // If it is a StringDatum, it can be casted to a string: std::string* s = dynamic_cast< std::string* >( t.datum() ); - if ( s != nullptr ) + if ( s ) { return *s; } @@ -164,7 +164,7 @@ getValue< std::string >( const Token& t ) // If it is a NameDatum, LiteralDatum or SymbolDatum, // (or even a BoolDatum!) it can be casted to a Name: Name* n = dynamic_cast< Name* >( t.datum() ); - if ( n != nullptr ) + if ( n ) { return n->toString(); } @@ -188,7 +188,7 @@ setValue< std::string >( const Token& t, std::string const& value ) { // If it is a StringDatum, it can be casted to a string: std::string* s = dynamic_cast< std::string* >( t.datum() ); - if ( s != nullptr ) + if ( s ) { *s = value; } @@ -197,7 +197,7 @@ setValue< std::string >( const Token& t, std::string const& value ) // If it is a BoolDatum, it -could- be set from a string, but // this operation shall not be allowed! BoolDatum* b = dynamic_cast< BoolDatum* >( t.datum() ); - if ( b != nullptr ) + if ( b ) { // We have to create Datum objects to get the expected names... StringDatum const d1; @@ -213,7 +213,7 @@ setValue< std::string >( const Token& t, std::string const& value ) // If it is a NameDatum, LiteralDatum or SymbolDatum, // it can be casted to a Name: Name* n = dynamic_cast< Name* >( t.datum() ); - if ( n != nullptr ) + if ( n ) { *n = Name( value ); } diff --git a/sli/triedatum.cc b/sli/triedatum.cc index be28bd56e7..4a070c3158 100644 --- a/sli/triedatum.cc +++ b/sli/triedatum.cc @@ -36,5 +36,5 @@ TrieDatum::equals( Datum const* dat ) const const TrieDatum* fd = dynamic_cast< TrieDatum* >( const_cast< Datum* >( dat ) ); - return fd != nullptr and tree == fd->tree; + return fd and tree == fd->tree; } diff --git a/sli/triedatum.h b/sli/triedatum.h index cf765f3765..2e0eebc8ad 100644 --- a/sli/triedatum.h +++ b/sli/triedatum.h @@ -146,7 +146,7 @@ class TrieDatum : public TypedDatum< &SLIInterpreter::Trietype > static void operator delete( void* p, size_t size ) { - if ( p == nullptr ) + if ( not p ) { return; } diff --git a/sli/typechk.cc b/sli/typechk.cc index ed9df8434b..357fb5c2c0 100644 --- a/sli/typechk.cc +++ b/sli/typechk.cc @@ -74,12 +74,12 @@ TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const } else { - assert( next != nullptr ); + assert( next ); a.push_back( LiteralDatum( type ) ); TokenArray a_next; next->toTokenArray( a_next ); a.push_back( ArrayDatum( a_next ) ); - if ( alt != nullptr ) + if ( alt ) { TokenArray a_alt; alt->toTokenArray( a_alt ); @@ -103,11 +103,11 @@ TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl } else { - assert( next != nullptr ); + assert( next ); tl.push_back( this ); next->info( out, tl ); tl.pop_back(); - if ( alt != nullptr ) + if ( alt ) { alt->info( out, tl ); } @@ -130,15 +130,15 @@ TypeTrie::newnode( const TokenArray& ta ) const // first object in the array must be a literal, indicating the type // the second and third object must be an array. LiteralDatum* typed = dynamic_cast< LiteralDatum* >( ta[ 0 ].datum() ); - assert( typed != nullptr ); + assert( typed ); ArrayDatum* nextd = dynamic_cast< ArrayDatum* >( ta[ 1 ].datum() ); - assert( nextd != nullptr ); + assert( nextd ); n = new TypeNode( *typed ); n->next = newnode( *nextd ); if ( ta.size() == 3 ) { ArrayDatum* altd = dynamic_cast< ArrayDatum* >( ta[ 2 ].datum() ); - assert( altd != nullptr ); + assert( altd ); n->alt = newnode( *altd ); } } @@ -235,7 +235,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) TypeNode* pos = root; const Name empty; - assert( root != nullptr ); + assert( root ); // Functions with no parameters are possible, but useless in trie // structures, so it is best to forbid them! @@ -280,7 +280,7 @@ void TypeTrie::toTokenArray( TokenArray& a ) const { a.clear(); - if ( root != nullptr ) + if ( root ) { root->toTokenArray( a ); } @@ -291,7 +291,7 @@ TypeTrie::info( std::ostream& out ) const { std::vector< TypeNode const* > tl; tl.reserve( 5 ); - if ( root != nullptr ) + if ( root ) { root->info( out, tl ); } diff --git a/sli/typechk.h b/sli/typechk.h index 4f51fef722..dd86e3ab38 100644 --- a/sli/typechk.h +++ b/sli/typechk.h @@ -121,11 +121,11 @@ class TypeTrie ~TypeNode() { - if ( next != nullptr ) + if ( next ) { next->removereference(); } - if ( alt != nullptr ) + if ( alt ) { alt->removereference(); } @@ -156,7 +156,7 @@ class TypeTrie TypeTrie( const TypeTrie& tt ) : root( tt.root ) { - if ( root != nullptr ) + if ( root ) { root->addreference(); } @@ -185,7 +185,7 @@ class TypeTrie inline TypeTrie::~TypeTrie() { - if ( root != nullptr ) + if ( root ) { root->removereference(); } @@ -233,7 +233,7 @@ TypeTrie::lookup( const TokenStack& st ) const while ( not equals( find_type, pos->type ) ) { - if ( pos->alt != nullptr ) + if ( pos->alt ) { pos = pos->alt; } From 9910f5684c4ac1cb15a033e36d7a54cb006211cd Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Fri, 7 Oct 2022 17:30:19 +0200 Subject: [PATCH 107/150] Replaced all ptr == nullptr checks by not ptr --- models/cm_tree.cpp | 2 +- models/stdp_dopamine_synapse.cpp | 4 +- nestkernel/kernel_manager.cpp | 2 +- nestkernel/model_manager.cpp | 2 +- nestkernel/nestmodule.cpp | 2 +- nestkernel/node_collection.h | 2 +- nestkernel/node_manager.cpp | 8 +- nestkernel/parameter.h | 2 +- nestkernel/spatial.h | 2 +- sli/aggregatedatum.h | 2 +- sli/allocator.h | 2 +- sli/booldatum.cc | 2 +- sli/dictutils.h | 4 +- sli/functiondatum.h | 4 +- sli/gnureadline.cc | 2 +- sli/numericdatum.h | 2 +- sli/sli_io.cc | 92 +++++++++--------- sli/sliarray.cc | 162 +++++++++++++++---------------- sli/slicontrol.cc | 2 +- sli/slidata.cc | 8 +- sli/slidict.cc | 2 +- sli/sligraphics.cc | 2 +- sli/slimath.cc | 4 +- sli/slistack.cc | 4 +- sli/slitype.cc | 2 +- sli/slitypecheck.cc | 8 +- sli/tarrayobj.cc | 6 +- sli/tokenarray.cc | 8 +- sli/tokenutils.cc | 14 +-- sli/typechk.cc | 4 +- sli/utils.cc | 2 +- 31 files changed, 182 insertions(+), 182 deletions(-) diff --git a/models/cm_tree.cpp b/models/cm_tree.cpp index 5874360d2e..c63811c496 100644 --- a/models/cm_tree.cpp +++ b/models/cm_tree.cpp @@ -190,7 +190,7 @@ nest::CompTree::add_compartment( Compartment* compartment, const long parent_ind * exception message */ Compartment* parent = get_compartment( parent_index, get_root(), 0 ); - if ( parent == nullptr ) + if ( not parent ) { std::string msg = "does not exist in tree, but was specified as a parent compartment"; throw UnknownCompartment( parent_index, msg ); diff --git a/models/stdp_dopamine_synapse.cpp b/models/stdp_dopamine_synapse.cpp index fa90419e98..2dc8a077b9 100644 --- a/models/stdp_dopamine_synapse.cpp +++ b/models/stdp_dopamine_synapse.cpp @@ -85,7 +85,7 @@ STDPDopaCommonProperties::set_status( const DictionaryDatum& d, ConnectorModel& const thread tid = kernel().vp_manager.get_thread_id(); Node* vt = kernel().node_manager.get_node_or_proxy( vtnode_id, tid ); vt_ = dynamic_cast< volume_transmitter* >( vt ); - if ( vt_ == nullptr ) + if ( not vt_ ) { throw BadProperty( "Dopamine source must be volume transmitter" ); } @@ -104,7 +104,7 @@ STDPDopaCommonProperties::set_status( const DictionaryDatum& d, ConnectorModel& Node* STDPDopaCommonProperties::get_node() { - if ( vt_ == nullptr ) + if ( not vt_ ) { throw BadProperty( "No volume transmitter has been assigned to the dopamine synapse." ); } diff --git a/nestkernel/kernel_manager.cpp b/nestkernel/kernel_manager.cpp index 56e4bc6488..5180ffd281 100644 --- a/nestkernel/kernel_manager.cpp +++ b/nestkernel/kernel_manager.cpp @@ -29,7 +29,7 @@ nest::KernelManager::create_kernel_manager() { #pragma omp critical( create_kernel_manager ) { - if ( kernel_manager_instance_ == nullptr ) + if ( not kernel_manager_instance_ ) { kernel_manager_instance_ = new KernelManager(); assert( kernel_manager_instance_ ); diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index c47fcaaebe..1f7bc763d4 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -79,7 +79,7 @@ ModelManager::~ModelManager() void ModelManager::initialize() { - if ( proxynode_model_ == nullptr ) + if ( not proxynode_model_ ) { proxynode_model_ = new GenericModel< proxynode >( "proxynode", "" ); proxynode_model_->set_type_id( 1 ); diff --git a/nestkernel/nestmodule.cpp b/nestkernel/nestmodule.cpp index e217bd4858..dd21fc9cfb 100644 --- a/nestkernel/nestmodule.cpp +++ b/nestkernel/nestmodule.cpp @@ -184,7 +184,7 @@ NestModule::create_mask( const Token& t ) { DictionaryDatum* dd = dynamic_cast< DictionaryDatum* >( t.datum() ); - if ( dd == nullptr ) + if ( not dd ) { throw BadProperty( "Mask must be masktype or dictionary." ); } diff --git a/nestkernel/node_collection.h b/nestkernel/node_collection.h index 937b9bacc6..b0a276171a 100644 --- a/nestkernel/node_collection.h +++ b/nestkernel/node_collection.h @@ -883,7 +883,7 @@ NodeCollectionComposite::operator==( NodeCollectionPTR rhs ) const // Checking if rhs_ptr is invalid first, to avoid segfaults. If rhs is a NodeCollectionPrimitive, // rhs_ptr will be a null pointer. - if ( rhs_ptr == nullptr or size_ != rhs_ptr->size() or parts_.size() != rhs_ptr->parts_.size() ) + if ( not rhs_ptr or size_ != rhs_ptr->size() or parts_.size() != rhs_ptr->parts_.size() ) { return false; } diff --git a/nestkernel/node_manager.cpp b/nestkernel/node_manager.cpp index 71132f8a3f..2eb0853a85 100644 --- a/nestkernel/node_manager.cpp +++ b/nestkernel/node_manager.cpp @@ -425,7 +425,7 @@ NodeManager::get_node_or_proxy( index node_id, thread t ) assert( 0 < node_id and node_id <= size() ); Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == nullptr ) + if ( not node ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -446,7 +446,7 @@ NodeManager::get_node_or_proxy( index node_id ) thread t = kernel().vp_manager.vp_to_thread( vp ); Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == nullptr ) + if ( not node ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -461,7 +461,7 @@ NodeManager::get_mpi_local_node_or_device_head( index node_id ) Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == nullptr ) + if ( not node ) { return kernel().model_manager.get_proxy_node( t, node_id ); } @@ -481,7 +481,7 @@ NodeManager::get_thread_siblings( index node_id ) const for ( size_t t = 0; t < num_threads; ++t ) { Node* node = local_nodes_[ t ].get_node_by_node_id( node_id ); - if ( node == nullptr ) + if ( not node ) { throw NoThreadSiblingsAvailable( node_id ); } diff --git a/nestkernel/parameter.h b/nestkernel/parameter.h index c08d793d2c..d080846863 100644 --- a/nestkernel/parameter.h +++ b/nestkernel/parameter.h @@ -375,7 +375,7 @@ class NodePosParameter : public Parameter { throw BadParameterValue( "Source or target position parameter can only be used when connecting." ); } - if ( node == nullptr ) + if ( not node ) { throw KernelException( "Node position parameter can only be used when connecting spatially distributed nodes." ); } diff --git a/nestkernel/spatial.h b/nestkernel/spatial.h index 215cfdf548..ec592f6efd 100644 --- a/nestkernel/spatial.h +++ b/nestkernel/spatial.h @@ -95,7 +95,7 @@ class LayerMetadata : public NodeCollectionMetadata operator==( const NodeCollectionMetadataPTR rhs ) const override { const auto rhs_layer_metadata = dynamic_cast< LayerMetadata* >( rhs.get() ); - if ( rhs_layer_metadata == nullptr ) + if ( not rhs_layer_metadata ) { return false; } diff --git a/sli/aggregatedatum.h b/sli/aggregatedatum.h index ce535fda3a..c284633f60 100644 --- a/sli/aggregatedatum.h +++ b/sli/aggregatedatum.h @@ -117,7 +117,7 @@ class AggregateDatum : public TypedDatum< slt >, public C static void operator delete( void* p, size_t size ) { - if ( p == nullptr ) + if ( not p ) { return; } diff --git a/sli/allocator.h b/sli/allocator.h index cd0db9d7c7..7904d7f40e 100644 --- a/sli/allocator.h +++ b/sli/allocator.h @@ -155,7 +155,7 @@ inline void* pool::alloc() { - if ( head == nullptr ) + if ( not head ) { grow( block_size ); block_size *= growth_factor; diff --git a/sli/booldatum.cc b/sli/booldatum.cc index 690c881f91..261b54bdb7 100644 --- a/sli/booldatum.cc +++ b/sli/booldatum.cc @@ -77,7 +77,7 @@ BoolDatum::operator new( size_t size ) void BoolDatum::operator delete( void* p, size_t size ) { - if ( p == nullptr ) + if ( not p ) { return; } diff --git a/sli/dictutils.h b/sli/dictutils.h index 856d4d599f..1df5d89734 100644 --- a/sli/dictutils.h +++ b/sli/dictutils.h @@ -100,7 +100,7 @@ get_double_in_range( const DictionaryDatum& d, Name const n, double min, double else { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == nullptr ) + if ( not id ) { throw TypeMismatch(); } @@ -164,7 +164,7 @@ get_long_in_range( const DictionaryDatum& d, Name const n, long min, long max, i else { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == nullptr ) + if ( not id ) { throw TypeMismatch(); } diff --git a/sli/functiondatum.h b/sli/functiondatum.h index 722e207b06..39208d4720 100644 --- a/sli/functiondatum.h +++ b/sli/functiondatum.h @@ -137,7 +137,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > equals( Datum const* dat ) const override { const FunctionDatum* fd = dynamic_cast< FunctionDatum* >( const_cast< Datum* >( dat ) ); - if ( fd == nullptr ) + if ( not fd ) { return false; } @@ -166,7 +166,7 @@ class FunctionDatum : public TypedDatum< &SLIInterpreter::Functiontype > static void operator delete( void* p, size_t size ) { - if ( p == nullptr ) + if ( not p ) { return; } diff --git a/sli/gnureadline.cc b/sli/gnureadline.cc index 9f64c94cc0..394645e0e0 100644 --- a/sli/gnureadline.cc +++ b/sli/gnureadline.cc @@ -59,7 +59,7 @@ GNUReadline::GNUReadlineFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); assert( sd ); char* line_read = readline( sd->c_str() ); - if ( line_read == nullptr ) + if ( not line_read ) { // We have received EOF (Ctrl-D), so we quit. std::cout << std::endl; diff --git a/sli/numericdatum.h b/sli/numericdatum.h index 5f3aad573c..67c6221fc5 100644 --- a/sli/numericdatum.h +++ b/sli/numericdatum.h @@ -100,7 +100,7 @@ class NumericDatum : public GenericDatum< D, slt > static void operator delete( void* p, size_t size ) { - if ( p == nullptr ) + if ( not p ) { return; } diff --git a/sli/sli_io.cc b/sli/sli_io.cc index e61b03a0bc..708b788345 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -79,7 +79,7 @@ MathLinkPutStringFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { StringDatum const d; Token t = i->OStack.top(); @@ -113,7 +113,7 @@ XIfstreamFunction::execute( SLIInterpreter* i ) const // -> false StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { StringDatum const d; Token t = i->OStack.top(); @@ -157,7 +157,7 @@ IfstreamFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { StringDatum const d; Token t = i->OStack.top(); @@ -205,7 +205,7 @@ OfstreamFunction::execute( SLIInterpreter* i ) const // -> false StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { StringDatum const d; Token t = i->OStack.top(); @@ -267,7 +267,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const StringDatum* md = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr or md == nullptr ) + if ( not sd or md == nullptr ) { StringDatum const d; Token t1 = i->OStack.pick( 1 ); @@ -330,7 +330,7 @@ IsstreamFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { StringDatum const d; Token t = i->OStack.top(); @@ -404,7 +404,7 @@ StrSStreamFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr ) + if ( not ostreamdatum ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -564,7 +564,7 @@ PrintFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr ) + if ( not ostreamdatum ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -610,7 +610,7 @@ PrettyprintFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -642,7 +642,7 @@ FlushFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -682,7 +682,7 @@ EndlFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -710,7 +710,7 @@ EndsFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -735,7 +735,7 @@ EatwhiteFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr or not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -766,7 +766,7 @@ CloseistreamFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr or not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -814,7 +814,7 @@ CloseostreamFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr ) + if ( not ostreamdatum ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -855,7 +855,7 @@ SetwFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -864,7 +864,7 @@ SetwFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( id == nullptr ) + if ( not id ) { IntegerDatum const d; Token t = i->OStack.top(); @@ -906,7 +906,7 @@ SetprecisionFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -915,7 +915,7 @@ SetprecisionFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( id == nullptr ) + if ( not id ) { IntegerDatum const d; Token t = i->OStack.top(); @@ -943,7 +943,7 @@ IOSFixedFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr or not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.pick( 1 ); @@ -971,7 +971,7 @@ IOSScientificFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -999,7 +999,7 @@ IOSDefaultFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1027,7 +1027,7 @@ IOSShowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1054,7 +1054,7 @@ IOSNoshowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1082,7 +1082,7 @@ IOSOctFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1109,7 +1109,7 @@ IOSHexFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1136,7 +1136,7 @@ IOSDecFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1163,7 +1163,7 @@ IOSShowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1190,7 +1190,7 @@ IOSNoshowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1217,7 +1217,7 @@ IOSLeftFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1246,7 +1246,7 @@ IOSRightFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1275,7 +1275,7 @@ IOSInternalFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1316,7 +1316,7 @@ GetcFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1356,7 +1356,7 @@ GetsFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1405,7 +1405,7 @@ GetlineFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1459,7 +1459,7 @@ IGoodFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1500,7 +1500,7 @@ IClearFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1534,7 +1534,7 @@ OClearFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1569,7 +1569,7 @@ IFailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1611,7 +1611,7 @@ OGoodFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1652,7 +1652,7 @@ IEofFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1694,7 +1694,7 @@ OEofFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( ostreamdatum == nullptr || not ostreamdatum->valid() ) + if ( not ostreamdatum || not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1749,7 +1749,7 @@ In_AvailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1775,7 +1775,7 @@ ReadDoubleFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr ) + if ( not istreamdatum ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1817,7 +1817,7 @@ ReadIntFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr ) + if ( not istreamdatum ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1866,7 +1866,7 @@ ReadWordFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( istreamdatum == nullptr || not istreamdatum->valid() ) + if ( not istreamdatum || not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 547fb6f6ac..976325d160 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -1773,7 +1773,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const { // check if the components are arrays of equal length. ArrayDatum* ad1 = dynamic_cast< ArrayDatum* >( ad->get( 0 ).datum() ); - if ( ad1 == nullptr ) + if ( not ad1 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -1782,7 +1782,7 @@ SLIArrayModule::MapThreadFunction::execute( SLIInterpreter* i ) const for ( size_t j = 1; j < ad->size(); ++j ) { ArrayDatum* ad2 = dynamic_cast< ArrayDatum* >( ad->get( j ).datum() ); - if ( ad2 == nullptr ) + if ( not ad2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -1829,7 +1829,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const } ArrayDatum* source = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); - if ( source == nullptr ) + if ( not source ) { i->message( SLIInterpreter::M_ERROR, "Put", "First argument must be an array." ); i->message( SLIInterpreter::M_ERROR, "Put", "Usage: [array] [d1 ...dn] obj Put -> [array]" ); @@ -1840,7 +1840,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const ArrayDatum* pos = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( pos == nullptr ) + if ( not pos ) { i->message( SLIInterpreter::M_ERROR, "Put", @@ -1855,7 +1855,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const { assert( t ); IntegerDatum* idx = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( idx == nullptr ) + if ( not idx ) { i->message( SLIInterpreter::M_ERROR, "Put", "Non integer index found." ); i->message( SLIInterpreter::M_ERROR, "Put", "Source array is unchanged." ); @@ -1884,7 +1884,7 @@ SLIArrayModule::Put_a_a_tFunction::execute( SLIInterpreter* i ) const if ( t < pos->end() - 1 ) { source = dynamic_cast< ArrayDatum* >( ( *source )[ j ].datum() ); - if ( source == nullptr ) + if ( not source ) { i->message( SLIInterpreter::M_ERROR, "Put", "Dimensions of index and array do not match." ); i->message( SLIInterpreter::M_ERROR, "Put", "Source array is unchanged." ); @@ -2078,37 +2078,37 @@ SLIArrayModule::AreaFunction::execute( SLIInterpreter* i ) const // i->raiseerror(i->ArgumentTypeError); // return; // } - if ( s_w_d == nullptr ) + if ( not s_w_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_y_d == nullptr ) + if ( not s_y_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_x_d == nullptr ) + if ( not s_x_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_h_d == nullptr ) + if ( not a_h_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_w_d == nullptr ) + if ( not a_w_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_y_d == nullptr ) + if ( not a_y_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_x_d == nullptr ) + if ( not a_x_d ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2347,32 +2347,32 @@ SLIArrayModule::Area2Function::execute( SLIInterpreter* i ) const // i->raiseerror(i->ArgumentTypeError); // return; // } - if ( s_y_d == nullptr ) + if ( not s_y_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( s_x_d == nullptr ) + if ( not s_x_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_h_d == nullptr ) + if ( not a_h_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_w_d == nullptr ) + if ( not a_w_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_y_d == nullptr ) + if ( not a_y_d ) { i->raiseerror( i->ArgumentTypeError ); return; } - if ( a_x_d == nullptr ) + if ( not a_x_d ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2446,7 +2446,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const IntegerDatum* x = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* y = dynamic_cast< IntegerDatum* >( i->OStack.pick( 2 ).datum() ); - if ( w == nullptr ) + if ( not w ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2454,7 +2454,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const return; } - if ( x == nullptr ) + if ( not x ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2462,7 +2462,7 @@ SLIArrayModule::Cv1dFunction::execute( SLIInterpreter* i ) const return; } - if ( y == nullptr ) + if ( not y ) { i->message( SLIInterpreter::M_ERROR, "cv1d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv1d", "Usage: y x w cv1d" ); @@ -2516,7 +2516,7 @@ SLIArrayModule::Cv2dFunction::execute( SLIInterpreter* i ) const IntegerDatum* w = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); IntegerDatum* in = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( w == nullptr ) + if ( not w ) { i->message( SLIInterpreter::M_ERROR, "cv2d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv2d", "Usage: i w cv2d" ); @@ -2524,7 +2524,7 @@ SLIArrayModule::Cv2dFunction::execute( SLIInterpreter* i ) const return; } - if ( in == nullptr ) + if ( not in ) { i->message( SLIInterpreter::M_ERROR, "cv2d", "integertype expected" ); i->message( SLIInterpreter::M_ERROR, "cv2d", "Usage: i w cv2d" ); @@ -2567,7 +2567,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const } ArrayDatum* a = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( a == nullptr ) + if ( not a ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument must be an array" ); i->raiseerror( i->ArgumentTypeError ); @@ -2575,7 +2575,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const } IntegerDatum* tmp = dynamic_cast< IntegerDatum* >( a->begin()->datum() ); - if ( tmp == nullptr ) + if ( not tmp ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2587,7 +2587,7 @@ SLIArrayModule::GetMaxFunction::execute( SLIInterpreter* i ) const while ( pos < a->size() ) { tmp2 = dynamic_cast< IntegerDatum* >( a->get( pos ).datum() ); - if ( tmp2 == nullptr ) + if ( not tmp2 ) { i->message( SLIInterpreter::M_ERROR, "GetMax", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2629,7 +2629,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const } ArrayDatum* a = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( a == nullptr ) + if ( not a ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument must be an array" ); i->raiseerror( i->ArgumentTypeError ); @@ -2638,7 +2638,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const IntegerDatum* tmp = dynamic_cast< IntegerDatum* >( a->begin()->datum() ); - if ( tmp == nullptr ) + if ( not tmp ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2650,7 +2650,7 @@ SLIArrayModule::GetMinFunction::execute( SLIInterpreter* i ) const while ( pos < a->size() ) { tmp2 = dynamic_cast< IntegerDatum* >( a->get( pos ).datum() ); - if ( tmp2 == nullptr ) + if ( not tmp2 ) { i->message( SLIInterpreter::M_ERROR, "GetMin", "argument array may only contain integers" ); i->raiseerror( i->ArgumentTypeError ); @@ -2942,7 +2942,7 @@ SLIArrayModule::IntVector2ArrayFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -2962,13 +2962,13 @@ SLIArrayModule::Add_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == nullptr ) + if ( not ivd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == nullptr ) + if ( not ivd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3000,13 +3000,13 @@ SLIArrayModule::Add_i_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3034,7 +3034,7 @@ SLIArrayModule::Neg_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3061,13 +3061,13 @@ SLIArrayModule::Sub_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == nullptr ) + if ( not ivd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == nullptr ) + if ( not ivd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3099,13 +3099,13 @@ SLIArrayModule::Mul_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == nullptr ) + if ( not ivd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == nullptr ) + if ( not ivd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3138,13 +3138,13 @@ SLIArrayModule::Mul_i_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3172,13 +3172,13 @@ SLIArrayModule::Mul_d_ivFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == nullptr ) + if ( not dd ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3206,13 +3206,13 @@ SLIArrayModule::Div_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd1 = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd1 == nullptr ) + if ( not ivd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* ivd2 = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ivd2 == nullptr ) + if ( not ivd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3252,7 +3252,7 @@ SLIArrayModule::Length_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* ivd = dynamic_cast< IntVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3275,13 +3275,13 @@ SLIArrayModule::Add_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == nullptr ) + if ( not dvd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == nullptr ) + if ( not dvd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3313,13 +3313,13 @@ SLIArrayModule::Sub_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == nullptr ) + if ( not dvd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == nullptr ) + if ( not dvd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3351,13 +3351,13 @@ SLIArrayModule::Add_d_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == nullptr ) + if ( not dd ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( dvd == nullptr ) + if ( not dvd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3387,13 +3387,13 @@ SLIArrayModule::Mul_d_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* dd = dynamic_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dd == nullptr ) + if ( not dd ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( dvd == nullptr ) + if ( not dvd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3423,7 +3423,7 @@ SLIArrayModule::Neg_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd == nullptr ) + if ( not dvd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3451,7 +3451,7 @@ SLIArrayModule::Inv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd == nullptr ) + if ( not dvd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3486,13 +3486,13 @@ SLIArrayModule::Mul_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == nullptr ) + if ( not dvd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == nullptr ) + if ( not dvd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3524,13 +3524,13 @@ SLIArrayModule::Div_dv_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == nullptr ) + if ( not dvd1 ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd2 = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd2 == nullptr ) + if ( not dvd2 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3570,7 +3570,7 @@ SLIArrayModule::Length_dvFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* dvd1 = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( dvd1 == nullptr ) + if ( not dvd1 ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3592,13 +3592,13 @@ SLIArrayModule::Get_dv_iFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* dvd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( dvd == nullptr ) + if ( not dvd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3625,13 +3625,13 @@ SLIArrayModule::Get_iv_iFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == nullptr ) + if ( not vd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3658,13 +3658,13 @@ SLIArrayModule::Get_iv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* id = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == nullptr ) + if ( not vd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3698,13 +3698,13 @@ SLIArrayModule::Get_dv_ivFunction::execute( SLIInterpreter* i ) const return; } IntVectorDatum* id = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 0 ).datum() ); - if ( id == nullptr ) + if ( not id ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* vd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 1 ).datum() ); - if ( vd == nullptr ) + if ( not vd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3739,19 +3739,19 @@ SLIArrayModule::Put_dv_i_dFunction::execute( SLIInterpreter* i ) const return; } DoubleDatum* val = dynamic_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - if ( val == nullptr ) + if ( not val ) { i->raiseerror( i->ArgumentTypeError ); return; } IntegerDatum* idxd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idxd == nullptr ) + if ( not idxd ) { i->raiseerror( i->ArgumentTypeError ); return; } DoubleVectorDatum* vecd = dynamic_cast< DoubleVectorDatum* >( i->OStack.pick( 2 ).datum() ); - if ( vecd == nullptr ) + if ( not vecd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3774,19 +3774,19 @@ SLIArrayModule::Put_iv_i_iFunction::execute( SLIInterpreter* i ) const { IntegerDatum* val = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( val == nullptr ) + if ( not val ) { i->raiseerror( i->ArgumentTypeError ); return; } IntegerDatum* idxd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idxd == nullptr ) + if ( not idxd ) { i->raiseerror( i->ArgumentTypeError ); return; } IntVectorDatum* vecd = dynamic_cast< IntVectorDatum* >( i->OStack.pick( 2 ).datum() ); - if ( vecd == nullptr ) + if ( not vecd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3813,7 +3813,7 @@ SLIArrayModule::DoubleVector2ArrayFunction::execute( SLIInterpreter* i ) const return; } DoubleVectorDatum* ivd = dynamic_cast< DoubleVectorDatum* >( i->OStack.top().datum() ); - if ( ivd == nullptr ) + if ( not ivd ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3833,7 +3833,7 @@ SLIArrayModule::Zeros_dvFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == nullptr ) + if ( not num ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3858,7 +3858,7 @@ SLIArrayModule::Ones_dvFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == nullptr ) + if ( not num ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3883,7 +3883,7 @@ SLIArrayModule::Zeros_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == nullptr ) + if ( not num ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -3908,7 +3908,7 @@ SLIArrayModule::Ones_ivFunction::execute( SLIInterpreter* i ) const return; } IntegerDatum* num = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( num == nullptr ) + if ( not num ) { i->raiseerror( i->ArgumentTypeError ); return; diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index 7057ce6474..a09d58f8ad 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -343,7 +343,7 @@ RepeatFunction::execute( SLIInterpreter* i ) const if ( proc ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( id == nullptr ) + if ( not id ) { throw ArgumentType( 1 ); } diff --git a/sli/slidata.cc b/sli/slidata.cc index c7ee414e87..de00ae6adc 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -87,7 +87,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const assert( i->OStack.load() > 1 ); ArrayDatum* idx = dynamic_cast< ArrayDatum* >( i->OStack.top().datum() ); - if ( idx == nullptr ) + if ( not idx ) { i->message( SLIInterpreter::M_ERROR, "get_a_a", "Second argument must be an array of indices." ); i->message( SLIInterpreter::M_ERROR, "get_a_a", "Usage: [a] [i1 .. in] get -> [a[i1] ... a[in]]" ); @@ -96,7 +96,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const } ArrayDatum* obj = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( obj == nullptr ) + if ( not obj ) { i->message( SLIInterpreter::M_ERROR, "get_a_a", "Usage: [a] [i1 .. in] get -> [a[i1] ... a[in]]" ); i->message( SLIInterpreter::M_ERROR, "get_a_a", "First argument must be an array." ); @@ -110,7 +110,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const for ( Token* t = idx->begin(); t != idx->end(); ++t ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( id == nullptr ) + if ( not id ) { std::ostringstream sout; @@ -284,7 +284,7 @@ Join_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - if ( s1 == nullptr || s2 == nullptr ) + if ( not s1 || s2 == nullptr ) { i->message( SLIInterpreter::M_ERROR, "join_s", "Usage: (string1) (string2) join_s" ); i->raiseerror( i->ArgumentTypeError ); diff --git a/sli/slidict.cc b/sli/slidict.cc index dfa1bc07ce..5d4a2804a8 100644 --- a/sli/slidict.cc +++ b/sli/slidict.cc @@ -649,7 +649,7 @@ DictconstructFunction::execute( SLIInterpreter* i ) const { Token& val = ( i->OStack.pick( n ) ); key = dynamic_cast< LiteralDatum* >( i->OStack.pick( n + 1 ).datum() ); - if ( key == nullptr ) + if ( not key ) { i->message( 30, "DictConstruct", "Literal expected. Maybe initializer list is in the wrong order." ); i->raiseerror( i->ArgumentTypeError ); diff --git a/sli/sligraphics.cc b/sli/sligraphics.cc index 76bf7bf75e..b426c11bde 100644 --- a/sli/sligraphics.cc +++ b/sli/sligraphics.cc @@ -81,7 +81,7 @@ SLIgraphics::ReadPGMFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( sd == nullptr ) + if ( not sd ) { i->raiseerror( i->ArgumentTypeError ); return; diff --git a/sli/slimath.cc b/sli/slimath.cc index 673113e995..5c3507e9e6 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -269,7 +269,7 @@ Mod_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( op1 == nullptr || op2 == nullptr ) + if ( not op1 || op2 == nullptr ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -859,7 +859,7 @@ Inv_dFunction::execute( SLIInterpreter* i ) const DoubleDatum* op = static_cast< DoubleDatum* >( i->OStack.top().datum() ); - if ( op == nullptr ) + if ( not op ) { i->raiseerror( i->ArgumentTypeError ); return; diff --git a/sli/slistack.cc b/sli/slistack.cc index eadf5183da..7cb1471601 100644 --- a/sli/slistack.cc +++ b/sli/slistack.cc @@ -253,13 +253,13 @@ RollFunction::execute( SLIInterpreter* i ) const } IntegerDatum* idn = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - if ( idn == nullptr ) + if ( not idn ) { throw ArgumentType( 1 ); } IntegerDatum* idk = dynamic_cast< IntegerDatum* >( i->OStack.top().datum() ); - if ( idk == nullptr ) + if ( not idk ) { throw ArgumentType( 0 ); } diff --git a/sli/slitype.cc b/sli/slitype.cc index 22835b1107..3b1b1381ad 100644 --- a/sli/slitype.cc +++ b/sli/slitype.cc @@ -59,7 +59,7 @@ SLIType::deletetypename() void SLIType::setdefaultaction( SLIFunction& c ) { - if ( defaultaction == nullptr ) + if ( not defaultaction ) { defaultaction = &c; } diff --git a/sli/slitypecheck.cc b/sli/slitypecheck.cc index 0cb0e41c94..0732eb0b81 100644 --- a/sli/slitypecheck.cc +++ b/sli/slitypecheck.cc @@ -56,7 +56,7 @@ TrieFunction::execute( SLIInterpreter* i ) const LiteralDatum* name = dynamic_cast< LiteralDatum* >( i->OStack.top().datum() ); - if ( name == nullptr ) + if ( not name ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -97,7 +97,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const TrieDatum* trie = dynamic_cast< TrieDatum* >( i->OStack.pick( 2 ).datum() ); - if ( trie == nullptr ) + if ( not trie ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -108,7 +108,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const // Construct a TypeArray from the TokenArray ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); - if ( ad == nullptr ) + if ( not ad ) { i->raiseerror( i->ArgumentTypeError ); return; @@ -127,7 +127,7 @@ AddtotrieFunction::execute( SLIInterpreter* i ) const { LiteralDatum* nd = dynamic_cast< LiteralDatum* >( t->datum() ); - if ( nd == nullptr ) + if ( not nd ) { std::ostringstream message; message << "In trie " << trie->getname() << ". " diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index c7e33c3721..919ac172bb 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -662,19 +662,19 @@ TokenArrayObj::info( std::ostream& out ) const bool TokenArrayObj::valid() const { - if ( p == nullptr ) + if ( not p ) { std::cerr << "TokenArrayObj::valid: Data pointer missing!" << std::endl; return false; } - if ( begin_of_free_storage == nullptr ) + if ( not begin_of_free_storage ) { std::cerr << "TokenArrayObj::valid: begin of free storage pointer missing!" << std::endl; return false; } - if ( end_of_free_storage == nullptr ) + if ( not end_of_free_storage ) { std::cerr << "TokenArrayObj::valid: end of free storage pointer missing!" << std::endl; return false; diff --git a/sli/tokenarray.cc b/sli/tokenarray.cc index 34f99aed59..f3bc9f518f 100644 --- a/sli/tokenarray.cc +++ b/sli/tokenarray.cc @@ -81,7 +81,7 @@ TokenArray::toVector( std::vector< long >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { IntegerDatum* targetid = dynamic_cast< IntegerDatum* >( idx->datum() ); - if ( targetid == nullptr ) + if ( not targetid ) { IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -99,7 +99,7 @@ TokenArray::toVector( std::vector< size_t >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { IntegerDatum* targetid = dynamic_cast< IntegerDatum* >( idx->datum() ); - if ( targetid == nullptr ) + if ( not targetid ) { IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -141,7 +141,7 @@ TokenArray::toVector( std::vector< std::string >& a ) const for ( Token* idx = begin(); idx != end(); ++idx ) { std::string* target = dynamic_cast< std::string* >( idx->datum() ); - if ( target == nullptr ) + if ( not target ) { StringDatum const d; throw TypeMismatch( d.gettypename().toString(), idx->datum()->gettypename().toString() ); @@ -154,7 +154,7 @@ TokenArray::toVector( std::vector< std::string >& a ) const bool TokenArray::valid() const { - if ( data == nullptr ) + if ( not data ) { return false; } diff --git a/sli/tokenutils.cc b/sli/tokenutils.cc index eff557a6b2..6e21316025 100644 --- a/sli/tokenutils.cc +++ b/sli/tokenutils.cc @@ -41,7 +41,7 @@ long getValue< long >( const Token& t ) { const IntegerDatum* id = dynamic_cast< const IntegerDatum* >( t.datum() ); - if ( id == nullptr ) + if ( not id ) { // We have to create a Datum object to get the name... IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -53,7 +53,7 @@ void setValue< long >( const Token& t, long const& value ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t.datum() ); - if ( id == nullptr ) + if ( not id ) { // We have to create a Datum object to get the name... IntegerDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -95,7 +95,7 @@ void setValue< double >( const Token& t, double const& value ) { DoubleDatum* id = dynamic_cast< DoubleDatum* >( t.datum() ); - if ( id == nullptr ) + if ( not id ) { // We have to create a Datum object to get the name... DoubleDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -115,7 +115,7 @@ bool getValue< bool >( const Token& t ) { BoolDatum* bd = dynamic_cast< BoolDatum* >( t.datum() ); - if ( bd == nullptr ) + if ( not bd ) { // We have to create a Datum object to get the name... BoolDatum const d( false ); throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -128,7 +128,7 @@ void setValue< bool >( const Token& t, bool const& value ) { BoolDatum* bd = dynamic_cast< BoolDatum* >( t.datum() ); - if ( bd == nullptr ) + if ( not bd ) { // We have to create a Datum object to get the name... BoolDatum const d( false ); throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -275,7 +275,7 @@ void setValue< std::vector< double > >( const Token& t, std::vector< double > const& value ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( t.datum() ); - if ( ad == nullptr ) + if ( not ad ) { // We have to create a Datum object to get the name... ArrayDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); @@ -332,7 +332,7 @@ void setValue< std::vector< long > >( const Token& t, std::vector< long > const& value ) { ArrayDatum* ad = dynamic_cast< ArrayDatum* >( t.datum() ); - if ( ad == nullptr ) + if ( not ad ) { // We have to create a Datum object to get the name... ArrayDatum const d; throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); diff --git a/sli/typechk.cc b/sli/typechk.cc index 357fb5c2c0..071b534286 100644 --- a/sli/typechk.cc +++ b/sli/typechk.cc @@ -68,7 +68,7 @@ void TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const { assert( a.size() == 0 ); - if ( next == nullptr and alt == nullptr ) // Leaf node + if ( not next and alt == nullptr ) // Leaf node { a.push_back( func ); } @@ -92,7 +92,7 @@ TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const void TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl ) const { - if ( next == nullptr and alt == nullptr ) // Leaf node + if ( not next and alt == nullptr ) // Leaf node { // print type list then function for ( int i = tl.size() - 1; i >= 0; --i ) diff --git a/sli/utils.cc b/sli/utils.cc index 5443aa9818..16aeee92af 100644 --- a/sli/utils.cc +++ b/sli/utils.cc @@ -34,7 +34,7 @@ array2vector( std::vector< long >& v, const TokenArray a ) for ( Token* t = a.begin(); t != a.end(); ++t ) { IntegerDatum* id = dynamic_cast< IntegerDatum* >( t->datum() ); - if ( id == nullptr ) + if ( not id ) { status = false; break; From 72702768b466240d897993d8fc9bd2f69e5e7ad3 Mon Sep 17 00:00:00 2001 From: clinssen Date: Sat, 8 Oct 2022 00:40:36 +0200 Subject: [PATCH 108/150] update docstring note about PYNEST_QUIET based on review Co-authored-by: Jochen Martin Eppler --- pynest/nest/lib/hl_api_info.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index 0419374af5..962692a9b3 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -202,8 +202,10 @@ def set_verbosity(level): .. note:: - If the environment variable PYNEST_QUIET is set, NEST will not print - welcome text containing the version and other information. + To suppress the usual output when NEST starts up (e.g. the welcome message and + version information) you can set the environment variable ``PYNEST_QUIET`` by + running ``export PYNEST_QUIET = 1`` on the command line before executing your + simulation script. Parameters ---------- From 7e40b3eeced860da3fc8934bbe9034a11d2b39b1 Mon Sep 17 00:00:00 2001 From: clinssen Date: Mon, 10 Oct 2022 10:03:23 +0200 Subject: [PATCH 109/150] update docstring note about PYNEST_QUIET based on review Co-authored-by: Jochen Martin Eppler --- pynest/nest/lib/hl_api_info.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index 962692a9b3..3f08bfed53 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -203,9 +203,8 @@ def set_verbosity(level): .. note:: To suppress the usual output when NEST starts up (e.g. the welcome message and - version information) you can set the environment variable ``PYNEST_QUIET`` by - running ``export PYNEST_QUIET = 1`` on the command line before executing your - simulation script. + version information) you can run ``export PYNEST_QUIET=1`` on the command + line before executing your simulation script. Parameters ---------- From dee94b53bf88851eb06de4be94bcc3def8a4bc48 Mon Sep 17 00:00:00 2001 From: clinssen Date: Mon, 10 Oct 2022 10:05:01 +0200 Subject: [PATCH 110/150] update docstring note about PYNEST_QUIET based on review --- pynest/nest/lib/hl_api_info.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index 3f08bfed53..0eefd4f72e 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -204,7 +204,7 @@ def set_verbosity(level): To suppress the usual output when NEST starts up (e.g. the welcome message and version information) you can run ``export PYNEST_QUIET=1`` on the command - line before executing your simulation script. + line before executing your simulation script. Parameters ---------- From 20628042053c38d0cd8b4a6b12775f7a0085a812 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Mon, 10 Oct 2022 11:53:17 +0200 Subject: [PATCH 111/150] Adding missing pointer checks --- models/aeif_cond_alpha.cpp | 6 +++--- models/aeif_cond_alpha_multisynapse.cpp | 2 +- models/aeif_cond_beta_multisynapse.cpp | 2 +- models/aeif_cond_exp.cpp | 6 +++--- models/aeif_psc_alpha.cpp | 6 +++--- models/aeif_psc_delta.cpp | 6 +++--- models/aeif_psc_delta_clopath.cpp | 6 +++--- models/aeif_psc_exp.cpp | 6 +++--- models/gif_cond_exp.cpp | 6 +++--- models/gif_cond_exp_multisynapse.cpp | 6 +++--- models/glif_cond.cpp | 2 +- models/hh_cond_beta_gap_traub.cpp | 6 +++--- models/hh_cond_exp_traub.cpp | 6 +++--- models/hh_psc_alpha.cpp | 6 +++--- models/hh_psc_alpha_clopath.cpp | 6 +++--- models/hh_psc_alpha_gap.cpp | 6 +++--- models/ht_neuron.cpp | 6 +++--- models/iaf_chxk_2008.cpp | 6 +++--- models/iaf_cond_alpha.cpp | 6 +++--- models/iaf_cond_alpha_mc.cpp | 6 +++--- models/iaf_cond_beta.cpp | 6 +++--- models/iaf_cond_exp.cpp | 6 +++--- models/iaf_cond_exp_sfa_rr.cpp | 6 +++--- models/pp_cond_exp_mc_urbanczik.cpp | 6 +++--- models/stdp_dopamine_synapse.h | 2 +- nestkernel/connection_manager.cpp | 2 +- nestkernel/connector_model_impl.h | 2 +- nestkernel/model_manager.h | 2 +- nestkernel/node_collection.cpp | 2 +- sli/fdstream.cc | 6 +++--- sli/fdstream.h | 6 +++--- sli/filesystem.cc | 2 +- sli/interpret.cc | 2 +- sli/sli_io.cc | 2 +- sli/slidata.cc | 2 +- sli/slimath.cc | 2 +- sli/token.h | 6 +++--- sli/typechk.cc | 10 +++++----- 38 files changed, 90 insertions(+), 90 deletions(-) diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index ba7c23cf91..4eca47e99e 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -385,7 +385,7 @@ nest::aeif_cond_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -394,7 +394,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -403,7 +403,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index 1585af37cc..569b8c5fad 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -415,7 +415,7 @@ aeif_cond_alpha_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index 320fe2cb25..17d7896a5f 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -423,7 +423,7 @@ aeif_cond_beta_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index 290e9cd49b..ca53f17e09 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -380,7 +380,7 @@ nest::aeif_cond_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -389,7 +389,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -398,7 +398,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index 9cd64d4723..480d95e92f 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -375,7 +375,7 @@ nest::aeif_psc_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -384,7 +384,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -393,7 +393,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 688f673096..3865318575 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -352,7 +352,7 @@ nest::aeif_psc_delta::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -360,7 +360,7 @@ nest::aeif_psc_delta::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -369,7 +369,7 @@ nest::aeif_psc_delta::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index d0cc52ab8c..3761148cfa 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -418,7 +418,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -426,7 +426,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -435,7 +435,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 8f909199f2..6ccc210a03 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -370,7 +370,7 @@ nest::aeif_psc_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -379,7 +379,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -388,7 +388,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index 2d7d5fbc78..3ecf4f170a 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -410,7 +410,7 @@ nest::gif_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -419,7 +419,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -428,7 +428,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index 55e2a0a250..b5f56fd41c 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -412,7 +412,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, state_size ); } @@ -421,7 +421,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -430,7 +430,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( state_size ); } diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index e9a57bbfba..01e343607f 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -531,7 +531,7 @@ nest::glif_cond::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index f759d715b2..e49798a153 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -408,7 +408,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -417,7 +417,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -426,7 +426,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index be50074528..51ade18feb 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -340,7 +340,7 @@ nest::hh_cond_exp_traub::init_buffers_() B_.I_stim_ = 0.0; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -349,7 +349,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -358,7 +358,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index bb83db9efa..1056b97fde 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -334,7 +334,7 @@ nest::hh_psc_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -343,7 +343,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -352,7 +352,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index 659d03030a..383e3873d4 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -360,7 +360,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -369,7 +369,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -378,7 +378,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index d4656e97cb..3fab86c3e8 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -398,7 +398,7 @@ nest::hh_psc_alpha_gap::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -407,7 +407,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-6, 0.0 ); } @@ -416,7 +416,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-6, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/ht_neuron.cpp b/models/ht_neuron.cpp index 732706ce09..c792a7d13f 100644 --- a/models/ht_neuron.cpp +++ b/models/ht_neuron.cpp @@ -663,7 +663,7 @@ nest::ht_neuron::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.integration_step_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -672,7 +672,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -681,7 +681,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_chxk_2008.cpp b/models/iaf_chxk_2008.cpp index b69e7174a0..e7f6174bde 100644 --- a/models/iaf_chxk_2008.cpp +++ b/models/iaf_chxk_2008.cpp @@ -305,7 +305,7 @@ nest::iaf_chxk_2008::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -314,7 +314,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -323,7 +323,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index 86df34a52a..d99da63ba8 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -318,7 +318,7 @@ nest::iaf_cond_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -327,7 +327,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -336,7 +336,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index 425def4ede..1ceafccb09 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -515,7 +515,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -524,7 +524,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -533,7 +533,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index c5b51c3464..8b943df0b7 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -325,7 +325,7 @@ nest::iaf_cond_beta::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -334,7 +334,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -343,7 +343,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index 63ac115d68..5255d4d3a1 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -296,7 +296,7 @@ nest::iaf_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -305,7 +305,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -314,7 +314,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index 15987a3b0d..dff4c328dc 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -332,7 +332,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -341,7 +341,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -350,7 +350,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index d9dc40a875..355ee6b757 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -516,7 +516,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( B_.s_ == nullptr ) + if ( not _ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -525,7 +525,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( B_.c_ == nullptr ) + if ( not _ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -534,7 +534,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( B_.e_ == nullptr ) + if ( not _ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/stdp_dopamine_synapse.h b/models/stdp_dopamine_synapse.h index ea6eafeddb..9dc3a55a9f 100644 --- a/models/stdp_dopamine_synapse.h +++ b/models/stdp_dopamine_synapse.h @@ -280,7 +280,7 @@ class stdp_dopamine_synapse : public Connection< targetidentifierT > void check_connection( Node& s, Node& t, rport receptor_type, const CommonPropertiesType& cp ) { - if ( cp.vt_ == nullptr ) + if ( not _ ) { throw BadProperty( "No volume transmitter has been assigned to the dopamine synapse." ); } diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index 9f344b4683..53ed61be8c 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -1575,7 +1575,7 @@ nest::ConnectionManager::remove_disabled_connections( const thread tid ) for ( synindex syn_id = 0; syn_id < connectors.size(); ++syn_id ) { - if ( connectors[ syn_id ] == nullptr ) + if ( not connectors[ syn_id ] ) { continue; } diff --git a/nestkernel/connector_model_impl.h b/nestkernel/connector_model_impl.h index 1715d029c8..6fab7744f1 100644 --- a/nestkernel/connector_model_impl.h +++ b/nestkernel/connector_model_impl.h @@ -264,7 +264,7 @@ GenericConnectorModel< ConnectionT >::add_connection_( Node& src, { assert( syn_id != invalid_synindex ); - if ( thread_local_connectors[ syn_id ] == nullptr ) + if ( not thread_local_connectors[ syn_id ] ) { // No homogeneous Connector with this syn_id exists, we need to create a new // homogeneous Connector. diff --git a/nestkernel/model_manager.h b/nestkernel/model_manager.h index b3a875b10d..f03e6244ef 100644 --- a/nestkernel/model_manager.h +++ b/nestkernel/model_manager.h @@ -325,7 +325,7 @@ ModelManager::get_num_connection_models() const inline void ModelManager::assert_valid_syn_id( synindex syn_id, thread t ) const { - if ( syn_id >= connection_models_[ t ].size() or connection_models_[ t ][ syn_id ] == nullptr ) + if ( syn_id >= connection_models_[ t ].size() or not connection_models_[ t ][ syn_id ] ) { throw UnknownSynapseType( syn_id ); } diff --git a/nestkernel/node_collection.cpp b/nestkernel/node_collection.cpp index 363cd408ca..abbf04448f 100644 --- a/nestkernel/node_collection.cpp +++ b/nestkernel/node_collection.cpp @@ -456,7 +456,7 @@ NodeCollectionPrimitive::slice( size_t start, size_t end, size_t step ) const } NodeCollectionPTR sliced_nc; - if ( step == 1 and metadata_ == nullptr ) + if ( step == 1 and not metadata_ ) { // Create primitive NodeCollection passing node IDs. // Subtract 1 because "end" is one past last element to take while constructor expects ID of last node. diff --git a/sli/fdstream.cc b/sli/fdstream.cc index 849ced82a0..e5279dee1c 100644 --- a/sli/fdstream.cc +++ b/sli/fdstream.cc @@ -129,7 +129,7 @@ fdbuf::close() void ofdstream::close() { - if ( rdbuf()->close() == nullptr ) + if ( not rdbuf()->close() ) { setstate( failbit ); } @@ -139,7 +139,7 @@ ofdstream::close() void ifdstream::close() { - if ( rdbuf()->close() == nullptr ) + if ( not rdbuf()->close() ) { setstate( failbit ); } @@ -148,7 +148,7 @@ ifdstream::close() void fdstream::close() { - if ( rdbuf()->close() == nullptr ) + if ( not rdbuf()->close() ) { setstate( failbit ); } diff --git a/sli/fdstream.h b/sli/fdstream.h index 3f3f4ad63f..b5852fdc8e 100644 --- a/sli/fdstream.h +++ b/sli/fdstream.h @@ -226,7 +226,7 @@ class ofdstream : public std::ostream void open( const char* s, std::ios_base::openmode mode = std::ios_base::out ) { - if ( rdbuf()->open( s, mode | std::ios_base::out ) == nullptr ) + if ( not rdbuf()->open( s, mode | std::ios_base::out ) ) { setstate( failbit ); } @@ -283,7 +283,7 @@ class ifdstream : public std::istream void open( const char* s, std::ios_base::openmode mode = std::ios_base::in ) { - if ( rdbuf()->open( s, mode | std::ios_base::in ) == nullptr ) + if ( not rdbuf()->open( s, mode | std::ios_base::in ) ) { setstate( failbit ); } @@ -341,7 +341,7 @@ class fdstream : public std::iostream void open( const char* s, std::ios_base::openmode mode ) { - if ( rdbuf()->open( s, mode ) == nullptr ) + if ( not rdbuf()->open( s, mode ) ) { setstate( failbit ); } diff --git a/sli/filesystem.cc b/sli/filesystem.cc index 89122a4475..679a88d069 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -139,7 +139,7 @@ FilesystemModule::DirectoryFunction::execute( SLIInterpreter* i ) const int size = SIZE; char* path_buffer = new char[ size ]; - while ( getcwd( path_buffer, size - 1 ) == nullptr ) + while ( not getcwd( path_buffer, size - 1 ) ) { // try again with a bigger buffer! if ( errno != ERANGE ) { diff --git a/sli/interpret.cc b/sli/interpret.cc index ffc4a46023..c2a5a7bad4 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -185,7 +185,7 @@ SLIInterpreter::inittypes() void SLIInterpreter::initdictionaries() { - assert( DStack == nullptr ); + assert( not DStack ); DStack = new DictionaryStack(); assert( DStack ); diff --git a/sli/sli_io.cc b/sli/sli_io.cc index 708b788345..3b8c31e389 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -267,7 +267,7 @@ OfsopenFunction::execute( SLIInterpreter* i ) const StringDatum* md = dynamic_cast< StringDatum* >( i->OStack.top().datum() ); - if ( not sd or md == nullptr ) + if ( not sd or not md ) { StringDatum const d; Token t1 = i->OStack.pick( 1 ); diff --git a/sli/slidata.cc b/sli/slidata.cc index de00ae6adc..5650187278 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -284,7 +284,7 @@ Join_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not s1 || s2 == nullptr ) + if ( not s1 or not s2 ) { i->message( SLIInterpreter::M_ERROR, "join_s", "Usage: (string1) (string2) join_s" ); i->raiseerror( i->ArgumentTypeError ); diff --git a/sli/slimath.cc b/sli/slimath.cc index 5c3507e9e6..df46615608 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -269,7 +269,7 @@ Mod_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not op1 || op2 == nullptr ) + if ( not op1 or not op2 ) { i->raiseerror( i->ArgumentTypeError ); return; diff --git a/sli/token.h b/sli/token.h index 6a795b594f..f1998a5de6 100644 --- a/sli/token.h +++ b/sli/token.h @@ -347,13 +347,13 @@ class Token bool empty() const { - return p == nullptr; + return not p; } bool operator not() const { - return p == nullptr; + return not p; } Datum* @@ -401,7 +401,7 @@ class Token return *this; } - if ( c_s.p == nullptr ) + if ( not p ) { clear(); return *this; diff --git a/sli/typechk.cc b/sli/typechk.cc index 071b534286..50e9e8c400 100644 --- a/sli/typechk.cc +++ b/sli/typechk.cc @@ -68,7 +68,7 @@ void TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const { assert( a.size() == 0 ); - if ( not next and alt == nullptr ) // Leaf node + if ( not next and not alt ) // Leaf node { a.push_back( func ); } @@ -92,7 +92,7 @@ TypeTrie::TypeNode::toTokenArray( TokenArray& a ) const void TypeTrie::TypeNode::info( std::ostream& out, std::vector< TypeNode const* >& tl ) const { - if ( not next and alt == nullptr ) // Leaf node + if ( not next and not alt ) // Leaf node { // print type list then function for ( int i = tl.size() - 1; i >= 0; --i ) @@ -173,7 +173,7 @@ TypeTrie::getalternative( TypeTrie::TypeNode* pos, const Name& type ) while ( type != pos->type ) { - if ( pos->alt == nullptr ) + if ( not pos->alt ) { pos->alt = new TypeNode( type ); } @@ -245,7 +245,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) { pos = getalternative( pos, a[ level ] ); - if ( pos->next == nullptr ) + if ( not pos->next ) { pos->next = new TypeNode( empty ); } @@ -258,7 +258,7 @@ TypeTrie::insert_move( const TypeArray& a, Token& f ) 2. If pos->alt != NULL, something undefined must have happened. This should be impossible. */ - if ( pos->next == nullptr ) + if ( not pos->next ) { pos->type = sli::object; pos->func.move( f ); From 419b7ec2a37911f6921232de452a98707b63ad66 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Mon, 10 Oct 2022 12:04:51 +0200 Subject: [PATCH 112/150] Fixing wrong replacement --- models/aeif_cond_alpha.cpp | 6 +++--- models/aeif_cond_alpha_multisynapse.cpp | 2 +- models/aeif_cond_beta_multisynapse.cpp | 2 +- models/aeif_cond_exp.cpp | 6 +++--- models/aeif_psc_alpha.cpp | 6 +++--- models/aeif_psc_delta.cpp | 6 +++--- models/aeif_psc_delta_clopath.cpp | 6 +++--- models/aeif_psc_exp.cpp | 6 +++--- models/gif_cond_exp.cpp | 6 +++--- models/gif_cond_exp_multisynapse.cpp | 6 +++--- models/glif_cond.cpp | 2 +- models/hh_cond_beta_gap_traub.cpp | 6 +++--- models/hh_cond_exp_traub.cpp | 6 +++--- models/hh_psc_alpha.cpp | 6 +++--- models/hh_psc_alpha_clopath.cpp | 6 +++--- models/hh_psc_alpha_gap.cpp | 6 +++--- models/ht_neuron.cpp | 6 +++--- models/iaf_chxk_2008.cpp | 6 +++--- models/iaf_cond_alpha.cpp | 6 +++--- models/iaf_cond_alpha_mc.cpp | 6 +++--- models/iaf_cond_beta.cpp | 6 +++--- models/iaf_cond_exp.cpp | 6 +++--- models/iaf_cond_exp_sfa_rr.cpp | 6 +++--- models/pp_cond_exp_mc_urbanczik.cpp | 6 +++--- models/stdp_dopamine_synapse.h | 2 +- 25 files changed, 67 insertions(+), 67 deletions(-) diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index 4eca47e99e..dfde99fab1 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -385,7 +385,7 @@ nest::aeif_cond_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -394,7 +394,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -403,7 +403,7 @@ nest::aeif_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index 569b8c5fad..82643fde31 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -415,7 +415,7 @@ aeif_cond_alpha_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index 17d7896a5f..7de5c41ce0 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -423,7 +423,7 @@ aeif_cond_beta_multisynapse::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index ca53f17e09..ec64b864fc 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -380,7 +380,7 @@ nest::aeif_cond_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -389,7 +389,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -398,7 +398,7 @@ nest::aeif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index 480d95e92f..687c72574f 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -375,7 +375,7 @@ nest::aeif_psc_alpha::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -384,7 +384,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -393,7 +393,7 @@ nest::aeif_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 3865318575..9c5985d602 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -352,7 +352,7 @@ nest::aeif_psc_delta::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -360,7 +360,7 @@ nest::aeif_psc_delta::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -369,7 +369,7 @@ nest::aeif_psc_delta::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index 3761148cfa..946e9410e2 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -418,7 +418,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -426,7 +426,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() { gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -435,7 +435,7 @@ nest::aeif_psc_delta_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 6ccc210a03..1904711f42 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -370,7 +370,7 @@ nest::aeif_psc_exp::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -379,7 +379,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } @@ -388,7 +388,7 @@ nest::aeif_psc_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index 3ecf4f170a..bc02952f9f 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -410,7 +410,7 @@ nest::gif_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -419,7 +419,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -428,7 +428,7 @@ nest::gif_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index b5f56fd41c..647d73cf58 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -412,7 +412,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, state_size ); } @@ -421,7 +421,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( P_.gsl_error_tol, 0.0 ); } @@ -430,7 +430,7 @@ nest::gif_cond_exp_multisynapse::init_buffers_() gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( state_size ); } diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 01e343607f..90e1e787c6 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -531,7 +531,7 @@ nest::glif_cond::init_buffers_() // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index e49798a153..10493561a5 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -408,7 +408,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -417,7 +417,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -426,7 +426,7 @@ nest::hh_cond_beta_gap_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index 51ade18feb..d3260e8a4e 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -340,7 +340,7 @@ nest::hh_cond_exp_traub::init_buffers_() B_.I_stim_ = 0.0; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -349,7 +349,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -358,7 +358,7 @@ nest::hh_cond_exp_traub::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index 1056b97fde..f06e7980c0 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -334,7 +334,7 @@ nest::hh_psc_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -343,7 +343,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -352,7 +352,7 @@ nest::hh_psc_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index 383e3873d4..51e00f3720 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -360,7 +360,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -369,7 +369,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -378,7 +378,7 @@ nest::hh_psc_alpha_clopath::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index 3fab86c3e8..af42bbab00 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -398,7 +398,7 @@ nest::hh_psc_alpha_gap::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -407,7 +407,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-6, 0.0 ); } @@ -416,7 +416,7 @@ nest::hh_psc_alpha_gap::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-6, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/ht_neuron.cpp b/models/ht_neuron.cpp index c792a7d13f..b76a960914 100644 --- a/models/ht_neuron.cpp +++ b/models/ht_neuron.cpp @@ -663,7 +663,7 @@ nest::ht_neuron::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.integration_step_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -672,7 +672,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -681,7 +681,7 @@ nest::ht_neuron::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_chxk_2008.cpp b/models/iaf_chxk_2008.cpp index e7f6174bde..f8e85565b1 100644 --- a/models/iaf_chxk_2008.cpp +++ b/models/iaf_chxk_2008.cpp @@ -305,7 +305,7 @@ nest::iaf_chxk_2008::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -314,7 +314,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -323,7 +323,7 @@ nest::iaf_chxk_2008::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index d99da63ba8..c01844737a 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -318,7 +318,7 @@ nest::iaf_cond_alpha::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -327,7 +327,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -336,7 +336,7 @@ nest::iaf_cond_alpha::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index 1ceafccb09..3461f38f71 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -515,7 +515,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -524,7 +524,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -533,7 +533,7 @@ nest::iaf_cond_alpha_mc::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index 8b943df0b7..a313a080c9 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -325,7 +325,7 @@ nest::iaf_cond_beta::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -334,7 +334,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -343,7 +343,7 @@ nest::iaf_cond_beta::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index 5255d4d3a1..befebba4fe 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -296,7 +296,7 @@ nest::iaf_cond_exp::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -305,7 +305,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -314,7 +314,7 @@ nest::iaf_cond_exp::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index dff4c328dc..c569a2125c 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -332,7 +332,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -341,7 +341,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -350,7 +350,7 @@ nest::iaf_cond_exp_sfa_rr::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index 355ee6b757..ffa7a7a14b 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -516,7 +516,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; - if ( not _ ) + if ( not B_.s_ ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } @@ -525,7 +525,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_step_reset( B_.s_ ); } - if ( not _ ) + if ( not B_.c_ ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } @@ -534,7 +534,7 @@ nest::pp_cond_exp_mc_urbanczik::init_buffers_() gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } - if ( not _ ) + if ( not B_.e_ ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } diff --git a/models/stdp_dopamine_synapse.h b/models/stdp_dopamine_synapse.h index 9dc3a55a9f..7862dfe4d9 100644 --- a/models/stdp_dopamine_synapse.h +++ b/models/stdp_dopamine_synapse.h @@ -280,7 +280,7 @@ class stdp_dopamine_synapse : public Connection< targetidentifierT > void check_connection( Node& s, Node& t, rport receptor_type, const CommonPropertiesType& cp ) { - if ( not _ ) + if ( not cp.vt_ ) { throw BadProperty( "No volume transmitter has been assigned to the dopamine synapse." ); } From ce99cf2aa6fce94c9ae50e7b4d1f9ece45478066 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Mon, 10 Oct 2022 13:14:36 +0200 Subject: [PATCH 113/150] Added missing c_s in token.h --- sli/token.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/token.h b/sli/token.h index f1998a5de6..658e245ef9 100644 --- a/sli/token.h +++ b/sli/token.h @@ -401,7 +401,7 @@ class Token return *this; } - if ( not p ) + if ( not c_s.p ) { clear(); return *this; From 7dc36daeab28440bc896286de4e806b383dcfc4c Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Mon, 10 Oct 2022 23:57:27 +0200 Subject: [PATCH 114/150] Changed all &&, || and ! to and, or and not --- libnestutil/lockptr.h | 2 +- libnestutil/stopwatch.h | 2 +- models/ac_generator.cpp | 2 +- models/aeif_cond_alpha.cpp | 2 +- models/aeif_cond_alpha_multisynapse.cpp | 6 +-- models/aeif_cond_beta_multisynapse.cpp | 8 ++-- models/aeif_cond_exp.cpp | 2 +- models/aeif_psc_alpha.cpp | 2 +- models/aeif_psc_delta.cpp | 4 +- models/aeif_psc_delta_clopath.cpp | 6 +-- models/aeif_psc_exp.cpp | 2 +- models/amat2_psc_exp.cpp | 2 +- models/binary_neuron.h | 4 +- models/cm_default.cpp | 6 +-- models/cm_tree.cpp | 4 +- models/correlation_detector.cpp | 8 ++-- models/correlation_detector.h | 2 +- models/correlomatrix_detector.cpp | 10 ++--- models/correlomatrix_detector.h | 2 +- models/correlospinmatrix_detector.cpp | 6 +-- models/correlospinmatrix_detector.h | 2 +- models/dc_generator.cpp | 2 +- models/gamma_sup_generator.cpp | 8 ++-- models/gif_cond_exp.cpp | 2 +- models/gif_cond_exp_multisynapse.cpp | 6 +-- models/gif_cond_exp_multisynapse.h | 2 +- models/gif_psc_exp.cpp | 2 +- models/gif_psc_exp_multisynapse.cpp | 6 +-- models/gif_psc_exp_multisynapse.h | 2 +- models/glif_psc.cpp | 2 +- models/hh_cond_beta_gap_traub.cpp | 6 +-- models/hh_cond_exp_traub.cpp | 6 +-- models/hh_psc_alpha.cpp | 6 +-- models/hh_psc_alpha_clopath.cpp | 6 +-- models/hh_psc_alpha_gap.cpp | 6 +-- models/ht_neuron.cpp | 2 +- models/ht_neuron.h | 2 +- models/ht_synapse.h | 4 +- models/iaf_chs_2007.cpp | 6 +-- models/iaf_cond_alpha.cpp | 2 +- models/iaf_cond_alpha_mc.cpp | 6 +-- models/iaf_cond_alpha_mc.h | 10 ++--- models/iaf_cond_beta.cpp | 2 +- models/iaf_cond_exp.cpp | 2 +- models/iaf_cond_exp_sfa_rr.cpp | 2 +- models/iaf_psc_alpha.cpp | 2 +- models/iaf_psc_alpha_canon.cpp | 8 ++-- models/iaf_psc_alpha_multisynapse.cpp | 4 +- models/iaf_psc_alpha_ps.cpp | 2 +- models/iaf_psc_delta.cpp | 4 +- models/iaf_psc_delta_ps.cpp | 4 +- models/iaf_psc_exp.cpp | 2 +- models/iaf_psc_exp_htum.cpp | 2 +- models/iaf_psc_exp_multisynapse.cpp | 2 +- models/iaf_psc_exp_ps.cpp | 2 +- models/iaf_psc_exp_ps_lossless.cpp | 2 +- models/izhikevich.cpp | 4 +- models/mat2_psc_exp.cpp | 2 +- models/multimeter.cpp | 4 +- models/multimeter.h | 2 +- models/music_cont_in_proxy.cpp | 2 +- models/music_cont_out_proxy.cpp | 2 +- models/music_event_out_proxy.cpp | 2 +- models/music_rate_in_proxy.cpp | 2 +- models/music_rate_out_proxy.cpp | 2 +- models/noise_generator.cpp | 4 +- models/parrot_neuron.cpp | 2 +- models/poisson_generator.cpp | 2 +- models/poisson_generator_ps.cpp | 4 +- models/pp_cond_exp_mc_urbanczik.cpp | 6 +-- models/pp_cond_exp_mc_urbanczik.h | 10 ++--- models/pp_psc_delta.cpp | 4 +- models/ppd_sup_generator.cpp | 8 ++-- models/rate_neuron_ipn_impl.h | 2 +- models/rate_neuron_opn_impl.h | 2 +- models/rate_transformer_node_impl.h | 2 +- models/siegert_neuron.cpp | 2 +- models/sinusoidal_gamma_generator.cpp | 8 ++-- models/sinusoidal_poisson_generator.cpp | 4 +- models/spike_generator.cpp | 10 ++--- models/spin_detector.cpp | 2 +- models/stdp_dopamine_synapse.h | 4 +- models/stdp_synapse_facetshw_hom.h | 6 +-- models/stdp_synapse_facetshw_hom_impl.h | 6 +-- models/step_current_generator.cpp | 6 +-- models/step_rate_generator.cpp | 6 +-- models/tsodyks2_synapse.h | 4 +- models/tsodyks_synapse.h | 2 +- nestkernel/clopath_archiving_node.cpp | 6 +-- nestkernel/connection_manager.cpp | 2 +- nestkernel/exceptions.h | 2 +- nestkernel/grid_layer.h | 4 +- nestkernel/mask.cpp | 8 ++-- nestkernel/mask_impl.h | 26 +++++------ nestkernel/ntree.h | 8 ++-- nestkernel/ntree_impl.h | 14 +++--- nestkernel/recording_backend_ascii.cpp | 2 +- nestkernel/recording_backend_sionlib.cpp | 2 +- nestkernel/recording_device.cpp | 2 +- nestkernel/slice_ring_buffer.h | 2 +- nestkernel/spatial.cpp | 2 +- nestkernel/universal_data_logger.h | 4 +- nestkernel/universal_data_logger_impl.h | 2 +- nestkernel/urbanczik_archiving_node_impl.h | 4 +- nestkernel/vp_manager.h | 2 +- sli/dict.h | 2 +- sli/dictutils.cc | 8 ++-- sli/fdstream.h | 2 +- sli/filesystem.cc | 6 +-- sli/interpret.cc | 28 ++++++------ sli/interpret.h | 2 +- sli/lockptrdatum.h | 2 +- sli/parser.cc | 2 +- sli/processes.cc | 4 +- sli/scanner.cc | 16 +++---- sli/sharedptrdatum.h | 2 +- sli/sli_io.cc | 50 +++++++++++----------- sli/sliarray.cc | 24 +++++------ sli/slibuiltins.cc | 4 +- sli/slicontrol.cc | 32 +++++++------- sli/slidata.cc | 46 ++++++++++---------- sli/slidict.cc | 2 +- sli/sliexceptions.cc | 2 +- sli/sligraphics.cc | 6 +-- sli/slimath.cc | 24 +++++------ sli/slistartup.cc | 2 +- sli/specialfunctionsmodule.cc | 2 +- sli/tarrayobj.cc | 6 +-- sli/tokenarray.h | 6 +-- sli/tokenstack.h | 2 +- sli/typechk.h | 2 +- 131 files changed, 361 insertions(+), 361 deletions(-) diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index 19b5ebc1e5..c1b7a26954 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -114,7 +114,7 @@ class lockPTR ~PointerObject() { assert( not locked ); - if ( ( pointee != NULL ) && deletable && ( not locked ) ) + if ( ( pointee != NULL ) and deletable and ( not locked ) ) { delete pointee; } diff --git a/libnestutil/stopwatch.h b/libnestutil/stopwatch.h index 6692afda98..00091c7360 100644 --- a/libnestutil/stopwatch.h +++ b/libnestutil/stopwatch.h @@ -158,7 +158,7 @@ class Stopwatch inline bool Stopwatch::correct_timeunit( timeunit_t t ) { - return t == MICROSEC || t == MILLISEC || t == SECONDS || t == MINUTES || t == HOURS || t == DAYS; + return t == MICROSEC or t == MILLISEC or t == SECONDS or t == MINUTES or t == HOURS or t == DAYS; } inline void diff --git a/models/ac_generator.cpp b/models/ac_generator.cpp index b1d81ce856..882ed3aa16 100644 --- a/models/ac_generator.cpp +++ b/models/ac_generator.cpp @@ -202,7 +202,7 @@ nest::ac_generator::pre_run_hook() void nest::ac_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); long start = origin.get_steps(); diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index dfde99fab1..60038d1bb4 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -448,7 +448,7 @@ nest::aeif_cond_alpha::pre_run_hook() void nest::aeif_cond_alpha::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index 82643fde31..e15418b494 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -233,7 +233,7 @@ aeif_cond_alpha_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* "The reversal potential, and synaptic time constant arrays " "must have the same size." ); } - if ( tau_syn.size() < old_n_receptors && has_connections_ ) + if ( tau_syn.size() < old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " @@ -486,7 +486,7 @@ aeif_cond_alpha_multisynapse::pre_run_hook() void aeif_cond_alpha_multisynapse::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); @@ -592,7 +592,7 @@ aeif_cond_alpha_multisynapse::handle( SpikeEvent& e ) "must be positive." ); } assert( e.get_delay_steps() > 0 ); - assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); + assert( ( e.get_rport() > 0 ) and ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index 7de5c41ce0..b1d4fdf59c 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -225,7 +225,7 @@ aeif_cond_beta_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* n { // receptor arrays have been modified if ( ( E_rev.size() != old_n_receptors || tau_rise.size() != old_n_receptors || tau_decay.size() != old_n_receptors ) - && ( not Erev_flag || not taur_flag || not taud_flag ) ) + and ( not Erev_flag || not taur_flag || not taud_flag ) ) { throw BadProperty( "If the number of receptor ports is changed, all three arrays " @@ -237,7 +237,7 @@ aeif_cond_beta_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* n "The reversal potential, synaptic rise time and synaptic decay time " "arrays must have the same size." ); } - if ( tau_rise.size() < old_n_receptors && has_connections_ ) + if ( tau_rise.size() < old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " @@ -495,7 +495,7 @@ aeif_cond_beta_multisynapse::pre_run_hook() void aeif_cond_beta_multisynapse::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); @@ -601,7 +601,7 @@ aeif_cond_beta_multisynapse::handle( SpikeEvent& e ) "must be positive." ); } assert( e.get_delay_steps() > 0 ); - assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); + assert( ( e.get_rport() > 0 ) and ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index ec64b864fc..dde180c7e7 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -441,7 +441,7 @@ nest::aeif_cond_exp::pre_run_hook() void nest::aeif_cond_exp::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index 687c72574f..6ae94934eb 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -438,7 +438,7 @@ nest::aeif_psc_alpha::pre_run_hook() void nest::aeif_psc_alpha::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 9c5985d602..42fa431d60 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -416,7 +416,7 @@ nest::aeif_psc_delta::pre_run_hook() void nest::aeif_psc_delta::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); const double h = Time::get_resolution().get_ms(); @@ -465,7 +465,7 @@ nest::aeif_psc_delta::update( const Time& origin, const long from, const long to // if we have accumulated spikes from refractory period, // add and reset accumulator - if ( P_.with_refr_input_ && S_.refr_spikes_buffer_ != 0.0 ) + if ( P_.with_refr_input_ and S_.refr_spikes_buffer_ != 0.0 ) { S_.y_[ State_::V_M ] += S_.refr_spikes_buffer_; S_.refr_spikes_buffer_ = 0.0; diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index 946e9410e2..648847a80c 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -475,7 +475,7 @@ nest::aeif_psc_delta_clopath::pre_run_hook() void nest::aeif_psc_delta_clopath::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); @@ -516,7 +516,7 @@ nest::aeif_psc_delta_clopath::update( const Time& origin, const long from, const // spikes are handled inside the while-loop // due to spike-driven adaptation - if ( S_.r_ == 0 && S_.clamp_r_ == 0 ) + if ( S_.r_ == 0 and S_.clamp_r_ == 0 ) { // neuron not refractory S_.y_[ State_::V_M ] = S_.y_[ State_::V_M ] + B_.spikes_.get_value( lag ); @@ -533,7 +533,7 @@ nest::aeif_psc_delta_clopath::update( const Time& origin, const long from, const // Delta_T == 0. } - if ( S_.y_[ State_::V_M ] >= V_.V_peak_ && S_.clamp_r_ == 0 ) + if ( S_.y_[ State_::V_M ] >= V_.V_peak_ and S_.clamp_r_ == 0 ) { S_.y_[ State_::V_M ] = P_.V_clamp_; S_.y_[ State_::W ] += P_.b; // spike-driven adaptation diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 1904711f42..2e61bfae9e 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -431,7 +431,7 @@ nest::aeif_psc_exp::pre_run_hook() void nest::aeif_psc_exp::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( State_::V_M == 0 ); diff --git a/models/amat2_psc_exp.cpp b/models/amat2_psc_exp.cpp index 62cc7a2d38..88575ef8e6 100644 --- a/models/amat2_psc_exp.cpp +++ b/models/amat2_psc_exp.cpp @@ -366,7 +366,7 @@ nest::amat2_psc_exp::pre_run_hook() void nest::amat2_psc_exp::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); // evolve from timestep 'from' to timestep 'to' with steps of h each diff --git a/models/binary_neuron.h b/models/binary_neuron.h index 54ab5f1aef..3d34835411 100644 --- a/models/binary_neuron.h +++ b/models/binary_neuron.h @@ -456,7 +456,7 @@ template < class TGainfunction > void binary_neuron< TGainfunction >::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -536,7 +536,7 @@ binary_neuron< TGainfunction >::handle( SpikeEvent& e ) if ( m == 1 ) { // multiplicity == 1, either a single 1->0 event or the first or second of a // pair of 0->1 events - if ( node_id == S_.last_in_node_id_ && t_spike == S_.t_last_in_spike_ ) + if ( node_id == S_.last_in_node_id_ and t_spike == S_.t_last_in_spike_ ) { // received twice the same node ID, so transition 0->1 // take double weight to compensate for subtracting first event diff --git a/models/cm_default.cpp b/models/cm_default.cpp index 482f1eda95..d3b6dc1240 100644 --- a/models/cm_default.cpp +++ b/models/cm_default.cpp @@ -290,7 +290,7 @@ nest::cm_default::pre_run_hook() void nest::cm_default::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -301,7 +301,7 @@ nest::cm_default::update( Time const& origin, const long from, const long to ) c_tree_.solve_matrix(); // threshold crossing - if ( c_tree_.get_root()->v_comp >= V_th_ && v_0_prev < V_th_ ) + if ( c_tree_.get_root()->v_comp >= V_th_ and v_0_prev < V_th_ ) { set_spiketime( Time::step( origin.get_steps() + lag + 1 ) ); @@ -322,7 +322,7 @@ nest::cm_default::handle( SpikeEvent& e ) } assert( e.get_delay_steps() > 0 ); - assert( ( e.get_rport() >= 0 ) && ( ( size_t ) e.get_rport() < syn_buffers_.size() ) ); + assert( ( e.get_rport() >= 0 ) and ( ( size_t ) e.get_rport() < syn_buffers_.size() ) ); syn_buffers_[ e.get_rport() ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); diff --git a/models/cm_tree.cpp b/models/cm_tree.cpp index c63811c496..969f99c254 100644 --- a/models/cm_tree.cpp +++ b/models/cm_tree.cpp @@ -241,14 +241,14 @@ nest::CompTree::get_compartment( const long compartment_index, Compartment* comp else { auto child_it = compartment->children.begin(); - while ( ( not r_compartment ) && child_it != compartment->children.end() ) + while ( ( not r_compartment ) and child_it != compartment->children.end() ) { r_compartment = get_compartment( compartment_index, &( *child_it ), 0 ); ++child_it; } } - if ( ( not r_compartment ) && raise_flag ) + if ( ( not r_compartment ) and raise_flag ) { std::string msg = "does not exist in tree"; throw UnknownCompartment( compartment_index, msg ); diff --git a/models/correlation_detector.cpp b/models/correlation_detector.cpp index 25fba71761..9c7b7d83d0 100644 --- a/models/correlation_detector.cpp +++ b/models/correlation_detector.cpp @@ -166,7 +166,7 @@ nest::correlation_detector::State_::set( const DictionaryDatum& d, const Paramet std::vector< long > nev; if ( updateValue< std::vector< long > >( d, names::n_events, nev ) ) { - if ( nev.size() == 2 && nev[ 0 ] == 0 && nev[ 1 ] == 0 ) + if ( nev.size() == 2 and nev[ 0 ] == 0 and nev[ 1 ] == 0 ) { reset_required = true; } @@ -264,7 +264,7 @@ nest::correlation_detector::handle( SpikeEvent& e ) // If this assertion breaks, the sender does not honor the // receiver port during connection or sending. - assert( 0 <= sender && sender <= 1 ); + assert( 0 <= sender and sender <= 1 ); // accept spikes only if detector was active when spike was emitted Time const stamp = e.get_stamp(); @@ -280,7 +280,7 @@ nest::correlation_detector::handle( SpikeEvent& e ) // throw away all spikes of the other neuron which are too old to // enter the correlation window // subtract 0.5*other to make left interval closed, keep right interval open - while ( not otherSpikes.empty() && ( spike_i - otherSpikes.front().timestep_ ) - 0.5 * other >= tau_edge ) + while ( not otherSpikes.empty() and ( spike_i - otherSpikes.front().timestep_ ) - 0.5 * other >= tau_edge ) { otherSpikes.pop_front(); } @@ -295,7 +295,7 @@ nest::correlation_detector::handle( SpikeEvent& e ) // only count events in histogram, if the current event is within the time // window [Tstart, Tstop] // this is needed in order to prevent boundary effects - if ( P_.Tstart_ <= stamp && stamp <= P_.Tstop_ ) + if ( P_.Tstart_ <= stamp and stamp <= P_.Tstop_ ) { // calculate the effect of this spike immediately with respect to all // spikes in the past of the respectively other source diff --git a/models/correlation_detector.h b/models/correlation_detector.h index d6008c4af6..85d72eec3e 100644 --- a/models/correlation_detector.h +++ b/models/correlation_detector.h @@ -310,7 +310,7 @@ class correlation_detector : public Node inline port correlation_detector::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type < 0 || receptor_type > 1 ) + if ( receptor_type < 0 or receptor_type > 1 ) { throw UnknownReceptorType( receptor_type, get_name() ); } diff --git a/models/correlomatrix_detector.cpp b/models/correlomatrix_detector.cpp index c671788641..44de2f8466 100644 --- a/models/correlomatrix_detector.cpp +++ b/models/correlomatrix_detector.cpp @@ -295,7 +295,7 @@ nest::correlomatrix_detector::handle( SpikeEvent& e ) // If this assertion breaks, the sender does not honor the // receiver port during connection or sending. - assert( 0 <= sender && sender <= P_.N_channels_ - 1 ); + assert( 0 <= sender and sender <= P_.N_channels_ - 1 ); // accept spikes only if detector was active when spike was emitted Time const stamp = e.get_stamp(); @@ -320,7 +320,7 @@ nest::correlomatrix_detector::handle( SpikeEvent& e ) // throw away all spikes which are too old to // enter the correlation window const delay min_delay = kernel().connection_manager.get_min_delay(); - while ( not otherSpikes.empty() && ( spike_i - otherSpikes.front().timestep_ ) >= tau_edge + min_delay ) + while ( not otherSpikes.empty() and ( spike_i - otherSpikes.front().timestep_ ) >= tau_edge + min_delay ) { otherSpikes.pop_front(); } @@ -331,7 +331,7 @@ nest::correlomatrix_detector::handle( SpikeEvent& e ) // window [Tstart, // Tstop] // this is needed in order to prevent boundary effects - if ( P_.Tstart_ <= stamp && stamp <= P_.Tstop_ ) + if ( P_.Tstart_ <= stamp and stamp <= P_.Tstop_ ) { // calculate the effect of this spike immediately with respect to all // spikes in the past of the respectively other sources @@ -371,14 +371,14 @@ nest::correlomatrix_detector::handle( SpikeEvent& e ) { // weighted histogram S_.covariance_[ sender_ind ][ other_ind ][ bin ] += e.get_multiplicity() * e.get_weight() * spike_j->weight_; - if ( bin == 0 && ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) + if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) { S_.covariance_[ other_ind ][ sender_ind ][ bin ] += e.get_multiplicity() * e.get_weight() * spike_j->weight_; } // pure (unweighted) count histogram S_.count_covariance_[ sender_ind ][ other_ind ][ bin ] += e.get_multiplicity(); - if ( bin == 0 && ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) + if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) { S_.count_covariance_[ other_ind ][ sender_ind ][ bin ] += e.get_multiplicity(); } diff --git a/models/correlomatrix_detector.h b/models/correlomatrix_detector.h index d66719aa4d..983a600cb3 100644 --- a/models/correlomatrix_detector.h +++ b/models/correlomatrix_detector.h @@ -300,7 +300,7 @@ class correlomatrix_detector : public Node inline port correlomatrix_detector::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type < 0 || receptor_type > P_.N_channels_ - 1 ) + if ( receptor_type < 0 or receptor_type > P_.N_channels_ - 1 ) { throw UnknownReceptorType( receptor_type, get_name() ); } diff --git a/models/correlospinmatrix_detector.cpp b/models/correlospinmatrix_detector.cpp index 46c1a70017..9dc0988a7b 100644 --- a/models/correlospinmatrix_detector.cpp +++ b/models/correlospinmatrix_detector.cpp @@ -305,7 +305,7 @@ nest::correlospinmatrix_detector::handle( SpikeEvent& e ) // If this assertion breaks, the sender does not honor the // receiver port during connection or sending. - assert( 0 <= curr_i && curr_i <= P_.N_channels_ - 1 ); + assert( 0 <= curr_i and curr_i <= P_.N_channels_ - 1 ); // accept spikes only if detector was active when spike was emitted Time const stamp = e.get_stamp(); @@ -329,7 +329,7 @@ nest::correlospinmatrix_detector::handle( SpikeEvent& e ) { // multiplicity == 1, either a single 1->0 event or the first or second of // a pair of 0->1 // events - if ( curr_i == S_.last_i_ && stamp == S_.t_last_in_spike_ ) + if ( curr_i == S_.last_i_ and stamp == S_.t_last_in_spike_ ) { // received twice the same node ID, so transition 0->1 // revise the last event written to the buffer @@ -398,7 +398,7 @@ nest::correlospinmatrix_detector::handle( SpikeEvent& e ) const double tau_edge = P_.tau_max_.get_steps() + P_.delta_tau_.get_steps(); const delay min_delay = kernel().connection_manager.get_min_delay(); - while ( not otherPulses.empty() && ( t_min_on - otherPulses.front().t_off_ ) >= tau_edge + min_delay ) + while ( not otherPulses.empty() and ( t_min_on - otherPulses.front().t_off_ ) >= tau_edge + min_delay ) { otherPulses.pop_front(); } diff --git a/models/correlospinmatrix_detector.h b/models/correlospinmatrix_detector.h index 7e697d9182..d7047fbe16 100644 --- a/models/correlospinmatrix_detector.h +++ b/models/correlospinmatrix_detector.h @@ -296,7 +296,7 @@ class correlospinmatrix_detector : public Node inline port correlospinmatrix_detector::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type < 0 || receptor_type > P_.N_channels_ - 1 ) + if ( receptor_type < 0 or receptor_type > P_.N_channels_ - 1 ) { throw UnknownReceptorType( receptor_type, get_name() ); } diff --git a/models/dc_generator.cpp b/models/dc_generator.cpp index 1c1cd4aa80..58969140e3 100644 --- a/models/dc_generator.cpp +++ b/models/dc_generator.cpp @@ -162,7 +162,7 @@ nest::dc_generator::pre_run_hook() void nest::dc_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); long start = origin.get_steps(); diff --git a/models/gamma_sup_generator.cpp b/models/gamma_sup_generator.cpp index 0adfa7a9af..5e52a18634 100644 --- a/models/gamma_sup_generator.cpp +++ b/models/gamma_sup_generator.cpp @@ -77,8 +77,8 @@ nest::gamma_sup_generator::Internal_states_::update( double transition_prob, Rng n >= 100 and np <= 10. Source: http://en.wikipedia.org/wiki/Binomial_distribution#Poisson_approximation */ - if ( ( occ_[ i ] >= 100 && transition_prob <= 0.01 ) - || ( occ_[ i ] >= 500 && transition_prob * occ_[ i ] <= 0.1 ) ) + if ( ( occ_[ i ] >= 100 and transition_prob <= 0.01 ) + || ( occ_[ i ] >= 500 and transition_prob * occ_[ i ] <= 0.1 ) ) { poisson_distribution::param_type param( transition_prob * occ_[ i ] ); n_trans[ i ] = poisson_dist_( rng, param ); @@ -232,7 +232,7 @@ nest::gamma_sup_generator::pre_run_hook() void nest::gamma_sup_generator::update( Time const& T, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) @@ -262,7 +262,7 @@ nest::gamma_sup_generator::event_hook( DSSpikeEvent& e ) const port prt = e.get_port(); // we handle only one port here, get reference to vector elem - assert( 0 <= prt && static_cast< size_t >( prt ) < B_.internal_states_.size() ); + assert( 0 <= prt and static_cast< size_t >( prt ) < B_.internal_states_.size() ); // age_distribution object propagates one time step and returns number of spikes unsigned long n_spikes = diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index bc02952f9f..9192938617 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -478,7 +478,7 @@ void nest::gif_cond_exp::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index 647d73cf58..ef3bfe2849 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -225,7 +225,7 @@ nest::gif_cond_exp_multisynapse::Parameters_::set( const DictionaryDatum& d, Nod "The reversal potential, and synaptic time constant arrays " "must have the same size." ); } - if ( tau_syn_.size() < old_n_receptors && has_connections_ ) + if ( tau_syn_.size() < old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " @@ -480,7 +480,7 @@ void nest::gif_cond_exp_multisynapse::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -595,7 +595,7 @@ nest::gif_cond_exp_multisynapse::handle( SpikeEvent& e ) "must be positive." ); } assert( e.get_delay_steps() > 0 ); - assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); + assert( ( e.get_rport() > 0 ) and ( ( size_t ) e.get_rport() <= P_.n_receptors() ) ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); diff --git a/models/gif_cond_exp_multisynapse.h b/models/gif_cond_exp_multisynapse.h index b3432170ad..fd024dcb18 100644 --- a/models/gif_cond_exp_multisynapse.h +++ b/models/gif_cond_exp_multisynapse.h @@ -452,7 +452,7 @@ gif_cond_exp_multisynapse::send_test_event( Node& target, rport receptor_type, s inline port gif_cond_exp_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/gif_psc_exp.cpp b/models/gif_psc_exp.cpp index 94e6ca306a..ee63f2fa28 100644 --- a/models/gif_psc_exp.cpp +++ b/models/gif_psc_exp.cpp @@ -326,7 +326,7 @@ void nest::gif_psc_exp::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/gif_psc_exp_multisynapse.cpp b/models/gif_psc_exp_multisynapse.cpp index 84c59b3c45..a1508c6c77 100644 --- a/models/gif_psc_exp_multisynapse.cpp +++ b/models/gif_psc_exp_multisynapse.cpp @@ -215,7 +215,7 @@ nest::gif_psc_exp_multisynapse::Parameters_::set( const DictionaryDatum& d, Node std::vector< double > tau_tmp; if ( updateValue< std::vector< double > >( d, names::tau_syn, tau_tmp ) ) { - if ( has_connections_ && tau_tmp.size() < tau_syn_.size() ) + if ( has_connections_ and tau_tmp.size() < tau_syn_.size() ) { throw BadProperty( "The neuron has connections, " @@ -348,7 +348,7 @@ void nest::gif_psc_exp_multisynapse::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -431,7 +431,7 @@ void gif_psc_exp_multisynapse::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); - assert( ( e.get_rport() > 0 ) && ( ( size_t ) e.get_rport() <= P_.n_receptors_() ) ); + assert( ( e.get_rport() > 0 ) and ( ( size_t ) e.get_rport() <= P_.n_receptors_() ) ); B_.spikes_[ e.get_rport() - 1 ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); diff --git a/models/gif_psc_exp_multisynapse.h b/models/gif_psc_exp_multisynapse.h index 6f3405ff71..2a83ec4b70 100644 --- a/models/gif_psc_exp_multisynapse.h +++ b/models/gif_psc_exp_multisynapse.h @@ -420,7 +420,7 @@ gif_psc_exp_multisynapse::send_test_event( Node& target, rport receptor_type, sy inline port gif_psc_exp_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors_() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors_() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/glif_psc.cpp b/models/glif_psc.cpp index 97e26b8c45..f4d9664afb 100644 --- a/models/glif_psc.cpp +++ b/models/glif_psc.cpp @@ -283,7 +283,7 @@ nest::glif_psc::Parameters_::set( const DictionaryDatum& d ) const size_t old_n_receptors = this->n_receptors_(); if ( updateValue< std::vector< double > >( d, names::tau_syn, tau_syn_ ) ) { - if ( this->n_receptors_() != old_n_receptors && has_connections_ ) + if ( this->n_receptors_() != old_n_receptors and has_connections_ ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index 10493561a5..093a48df26 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -476,7 +476,7 @@ nest::hh_cond_beta_gap_traub::update_( Time const& origin, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t interpolation_order = kernel().simulation_manager.get_wfr_interpolation_order(); @@ -552,8 +552,8 @@ nest::hh_cond_beta_gap_traub::update_( Time const& origin, --S_.r_; } else - // ( threshold && maximum ) - if ( S_.y_[ State_::V_M ] >= P_.V_T + 30. && U_old > S_.y_[ State_::V_M ] ) + // ( threshold and maximum ) + if ( S_.y_[ State_::V_M ] >= P_.V_T + 30. and U_old > S_.y_[ State_::V_M ] ) { S_.r_ = V_.refractory_counts_; diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index d3260e8a4e..bbabbcde81 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -388,7 +388,7 @@ nest::hh_cond_exp_traub::pre_run_hook() void nest::hh_cond_exp_traub::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -426,8 +426,8 @@ nest::hh_cond_exp_traub::update( Time const& origin, const long from, const long } else { - // (threshold && maximum ) - if ( S_.y_[ State_::V_M ] >= P_.V_T + 30. && V_.U_old_ > S_.y_[ State_::V_M ] ) + // (threshold and maximum ) + if ( S_.y_[ State_::V_M ] >= P_.V_T + 30. and V_.U_old_ > S_.y_[ State_::V_M ] ) { S_.r_ = V_.refractory_counts_; diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index f06e7980c0..0c0f7e710d 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -390,7 +390,7 @@ void nest::hh_psc_alpha::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -437,8 +437,8 @@ nest::hh_psc_alpha::update( Time const& origin, const long from, const long to ) --S_.r_; } else - // ( threshold && maximum ) - if ( S_.y_[ State_::V_M ] >= 0 && U_old > S_.y_[ State_::V_M ] ) + // ( threshold and maximum ) + if ( S_.y_[ State_::V_M ] >= 0 and U_old > S_.y_[ State_::V_M ] ) { S_.r_ = V_.RefractoryCounts_; diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index 51e00f3720..f476ecd83b 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -418,7 +418,7 @@ void nest::hh_psc_alpha_clopath::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -472,8 +472,8 @@ nest::hh_psc_alpha_clopath::update( Time const& origin, const long from, const l --S_.r_; } else - // ( threshold && maximum ) - if ( S_.y_[ State_::V_M ] >= 0 && U_old > S_.y_[ State_::V_M ] ) + // ( threshold and maximum ) + if ( S_.y_[ State_::V_M ] >= 0 and U_old > S_.y_[ State_::V_M ] ) { S_.r_ = V_.RefractoryCounts_; diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index af42bbab00..cf5a715624 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -454,7 +454,7 @@ bool nest::hh_psc_alpha_gap::update_( Time const& origin, const long from, const long to, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t interpolation_order = kernel().simulation_manager.get_wfr_interpolation_order(); @@ -530,8 +530,8 @@ nest::hh_psc_alpha_gap::update_( Time const& origin, const long from, const long --S_.r_; } else - // ( threshold && maximum ) - if ( S_.y_[ State_::V_M ] >= 0 && U_old > S_.y_[ State_::V_M ] ) + // ( threshold and maximum ) + if ( S_.y_[ State_::V_M ] >= 0 and U_old > S_.y_[ State_::V_M ] ) { S_.r_ = V_.RefractoryCounts_; diff --git a/models/ht_neuron.cpp b/models/ht_neuron.cpp index b76a960914..cd9f545ce1 100644 --- a/models/ht_neuron.cpp +++ b/models/ht_neuron.cpp @@ -770,7 +770,7 @@ nest::ht_neuron::set_status( const DictionaryDatum& d ) void ht_neuron::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/ht_neuron.h b/models/ht_neuron.h index d2a2936a62..0a0596dd22 100644 --- a/models/ht_neuron.h +++ b/models/ht_neuron.h @@ -528,7 +528,7 @@ ht_neuron::handles_test_event( SpikeEvent&, rport receptor_type ) { assert( B_.spike_inputs_.size() == 4 ); - if ( not( INF_SPIKE_RECEPTOR < receptor_type && receptor_type < SUP_SPIKE_RECEPTOR ) ) + if ( not( INF_SPIKE_RECEPTOR < receptor_type and receptor_type < SUP_SPIKE_RECEPTOR ) ) { throw UnknownReceptorType( receptor_type, get_name() ); return 0; diff --git a/models/ht_synapse.h b/models/ht_synapse.h index 410446a293..435819bc72 100644 --- a/models/ht_synapse.h +++ b/models/ht_synapse.h @@ -249,12 +249,12 @@ ht_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Connector throw BadProperty( "tau_P > 0 required." ); } - if ( delta_P_ < 0.0 || delta_P_ > 1.0 ) + if ( delta_P_ < 0.0 or delta_P_ > 1.0 ) { throw BadProperty( "0 <= delta_P <= 1 required." ); } - if ( p_ < 0.0 || p_ > 1.0 ) + if ( p_ < 0.0 or p_ > 1.0 ) { throw BadProperty( "0 <= P <= 1 required." ); } diff --git a/models/iaf_chs_2007.cpp b/models/iaf_chs_2007.cpp index a46dcddcbf..b71c13adb2 100644 --- a/models/iaf_chs_2007.cpp +++ b/models/iaf_chs_2007.cpp @@ -118,7 +118,7 @@ nest::iaf_chs_2007::Parameters_::set( const DictionaryDatum& d, State_& s, Node* /* // TODO: How to handle setting U_noise first and noise later and still make sure they are consistent? - if ( U_noise_ > 0 && noise_.empty() ) + if ( U_noise_ > 0 and noise_.empty() ) throw BadProperty("Noise amplitude larger than zero while noise signal " "is missing."); */ @@ -222,7 +222,7 @@ nest::iaf_chs_2007::pre_run_hook() void nest::iaf_chs_2007::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); // evolve from timestep 'from' to timestep 'to' with steps of h each @@ -240,7 +240,7 @@ nest::iaf_chs_2007::update( const Time& origin, const long from, const long to ) // exponentially decaying ahp S_.V_spike_ *= V_.P30_; - double noise_term = P_.U_noise_ > 0.0 && not P_.noise_.empty() ? P_.U_noise_ * P_.noise_[ S_.position_++ ] : 0.0; + double noise_term = P_.U_noise_ > 0.0 and not P_.noise_.empty() ? P_.U_noise_ * P_.noise_[ S_.position_++ ] : 0.0; S_.V_m_ = S_.V_syn_ + S_.V_spike_ + noise_term; diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index c01844737a..91c69c6b4a 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -375,7 +375,7 @@ void nest::iaf_cond_alpha::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index 3461f38f71..e6b516af9e 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -579,7 +579,7 @@ void nest::iaf_cond_alpha_mc::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -659,7 +659,7 @@ void nest::iaf_cond_alpha_mc::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); - assert( 0 <= e.get_rport() && e.get_rport() < 2 * NCOMP ); + assert( 0 <= e.get_rport() and e.get_rport() < 2 * NCOMP ); B_.spikes_[ e.get_rport() ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); @@ -670,7 +670,7 @@ nest::iaf_cond_alpha_mc::handle( CurrentEvent& e ) { assert( e.get_delay_steps() > 0 ); // not 100% clean, should look at MIN, SUP - assert( 0 <= e.get_rport() && e.get_rport() < NCOMP ); + assert( 0 <= e.get_rport() and e.get_rport() < NCOMP ); // add weighted current; HEP 2002-10-04 B_.currents_[ e.get_rport() ].add_value( diff --git a/models/iaf_cond_alpha_mc.h b/models/iaf_cond_alpha_mc.h index 6fb829d7ab..1ddf27c72d 100644 --- a/models/iaf_cond_alpha_mc.h +++ b/models/iaf_cond_alpha_mc.h @@ -477,9 +477,9 @@ iaf_cond_alpha_mc::send_test_event( Node& target, rport receptor_type, synindex, inline port iaf_cond_alpha_mc::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type < MIN_SPIKE_RECEPTOR || receptor_type >= SUP_SPIKE_RECEPTOR ) + if ( receptor_type < MIN_SPIKE_RECEPTOR or receptor_type >= SUP_SPIKE_RECEPTOR ) { - if ( receptor_type < 0 || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < 0 or receptor_type >= SUP_CURR_RECEPTOR ) { throw UnknownReceptorType( receptor_type, get_name() ); } @@ -494,9 +494,9 @@ iaf_cond_alpha_mc::handles_test_event( SpikeEvent&, rport receptor_type ) inline port iaf_cond_alpha_mc::handles_test_event( CurrentEvent&, rport receptor_type ) { - if ( receptor_type < MIN_CURR_RECEPTOR || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < MIN_CURR_RECEPTOR or receptor_type >= SUP_CURR_RECEPTOR ) { - if ( receptor_type >= 0 && receptor_type < MIN_CURR_RECEPTOR ) + if ( receptor_type >= 0 and receptor_type < MIN_CURR_RECEPTOR ) { throw IncompatibleReceptorType( receptor_type, get_name(), "CurrentEvent" ); } @@ -513,7 +513,7 @@ iaf_cond_alpha_mc::handles_test_event( DataLoggingRequest& dlr, rport receptor_t { if ( receptor_type != 0 ) { - if ( receptor_type < 0 || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < 0 or receptor_type >= SUP_CURR_RECEPTOR ) { throw UnknownReceptorType( receptor_type, get_name() ); } diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index a313a080c9..3b0dd040ca 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -388,7 +388,7 @@ void nest::iaf_cond_beta::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index befebba4fe..cd8976de5f 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -350,7 +350,7 @@ void nest::iaf_cond_exp::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index c569a2125c..48852fc66e 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -386,7 +386,7 @@ void nest::iaf_cond_exp_sfa_rr::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_psc_alpha.cpp b/models/iaf_psc_alpha.cpp index e6cf6737c2..262289b17c 100644 --- a/models/iaf_psc_alpha.cpp +++ b/models/iaf_psc_alpha.cpp @@ -306,7 +306,7 @@ iaf_psc_alpha::pre_run_hook() void iaf_psc_alpha::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_psc_alpha_canon.cpp b/models/iaf_psc_alpha_canon.cpp index 9831b44786..e7af99117f 100644 --- a/models/iaf_psc_alpha_canon.cpp +++ b/models/iaf_psc_alpha_canon.cpp @@ -154,7 +154,7 @@ nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) long tmp; if ( updateValue< long >( d, names::Interpol_Order, tmp ) ) { - if ( NO_INTERPOL <= tmp && tmp < END_INTERP_ORDER ) + if ( NO_INTERPOL <= tmp and tmp < END_INTERP_ORDER ) { Interpol_ = static_cast< interpOrder >( tmp ); } @@ -322,7 +322,7 @@ nest::iaf_psc_alpha_canon::update( Time const& origin, const long from, const lo const long T = origin.get_steps() + lag; // if neuron returns from refractoriness during this step, place // pseudo-event in queue to mark end of refractory period - if ( S_.is_refractory_ && ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) + if ( S_.is_refractory_ and ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) { B_.events_.add_refractory( T, S_.last_spike_offset_ ); } @@ -656,11 +656,11 @@ nest::iaf_psc_alpha_canon::thresh_find3_( double const dt ) const // set tau to the smallest root above 0 double tau = ( tau1 >= 0 ) ? tau1 : 2 * h_ms; - if ( ( tau2 >= 0 ) && ( tau2 < tau ) ) + if ( ( tau2 >= 0 ) and ( tau2 < tau ) ) { tau = tau2; } - if ( ( tau3 >= 0 ) && ( tau3 < tau ) ) + if ( ( tau3 >= 0 ) and ( tau3 < tau ) ) { tau = tau3; } diff --git a/models/iaf_psc_alpha_multisynapse.cpp b/models/iaf_psc_alpha_multisynapse.cpp index 0a16644540..59dc9e0595 100644 --- a/models/iaf_psc_alpha_multisynapse.cpp +++ b/models/iaf_psc_alpha_multisynapse.cpp @@ -185,7 +185,7 @@ iaf_psc_alpha_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* no const size_t old_n_receptors = this->n_receptors_(); if ( updateValue< std::vector< double > >( d, "tau_syn", tau_syn_ ) ) { - if ( this->n_receptors_() != old_n_receptors && has_connections_ == true ) + if ( this->n_receptors_() != old_n_receptors and has_connections_ == true ) { throw BadProperty( "The neuron has connections, therefore the number of ports cannot be " @@ -328,7 +328,7 @@ iaf_psc_alpha_multisynapse::pre_run_hook() void iaf_psc_alpha_multisynapse::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/iaf_psc_alpha_ps.cpp b/models/iaf_psc_alpha_ps.cpp index be1f8b8076..9dec1aa519 100644 --- a/models/iaf_psc_alpha_ps.cpp +++ b/models/iaf_psc_alpha_ps.cpp @@ -325,7 +325,7 @@ nest::iaf_psc_alpha_ps::update( Time const& origin, const long from, const long const long T = origin.get_steps() + lag; // if neuron returns from refractoriness during this step, place // pseudo-event in queue to mark end of refractory period - if ( S_.is_refractory_ && ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) + if ( S_.is_refractory_ and ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) { B_.events_.add_refractory( T, S_.last_spike_offset_ ); } diff --git a/models/iaf_psc_delta.cpp b/models/iaf_psc_delta.cpp index 5f991e2cc2..f673586250 100644 --- a/models/iaf_psc_delta.cpp +++ b/models/iaf_psc_delta.cpp @@ -270,7 +270,7 @@ nest::iaf_psc_delta::pre_run_hook() void nest::iaf_psc_delta::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const double h = Time::get_resolution().get_ms(); @@ -283,7 +283,7 @@ nest::iaf_psc_delta::update( Time const& origin, const long from, const long to // if we have accumulated spikes from refractory period, // add and reset accumulator - if ( P_.with_refr_input_ && S_.refr_spikes_buffer_ != 0.0 ) + if ( P_.with_refr_input_ and S_.refr_spikes_buffer_ != 0.0 ) { S_.y3_ += S_.refr_spikes_buffer_; S_.refr_spikes_buffer_ = 0.0; diff --git a/models/iaf_psc_delta_ps.cpp b/models/iaf_psc_delta_ps.cpp index c0e85768cd..ffd1c67774 100644 --- a/models/iaf_psc_delta_ps.cpp +++ b/models/iaf_psc_delta_ps.cpp @@ -304,7 +304,7 @@ iaf_psc_delta_ps::update( Time const& origin, const long from, const long to ) double t = V_.h_ms_; // place pseudo-event in queue to mark end of refractory period - if ( S_.is_refractory_ && ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) + if ( S_.is_refractory_ and ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) { B_.events_.add_refractory( T, S_.last_spike_offset_ ); } @@ -429,7 +429,7 @@ iaf_psc_delta_ps::update( Time const& origin, const long from, const long to ) // no events remaining, plain update step across remainder // of interval - if ( not S_.is_refractory_ && t > 0 ) // not at end of step, do remainder + if ( not S_.is_refractory_ and t > 0 ) // not at end of step, do remainder { propagate_( t ); if ( S_.U_ >= P_.U_th_ ) diff --git a/models/iaf_psc_exp.cpp b/models/iaf_psc_exp.cpp index e6201d792c..dbb90f9e84 100644 --- a/models/iaf_psc_exp.cpp +++ b/models/iaf_psc_exp.cpp @@ -287,7 +287,7 @@ nest::iaf_psc_exp::pre_run_hook() void nest::iaf_psc_exp::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const double h = Time::get_resolution().get_ms(); diff --git a/models/iaf_psc_exp_htum.cpp b/models/iaf_psc_exp_htum.cpp index 802a207620..33b9c297d2 100644 --- a/models/iaf_psc_exp_htum.cpp +++ b/models/iaf_psc_exp_htum.cpp @@ -298,7 +298,7 @@ nest::iaf_psc_exp_htum::pre_run_hook() void nest::iaf_psc_exp_htum::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); // evolve from timestep 'from' to timestep 'to' with steps of h each diff --git a/models/iaf_psc_exp_multisynapse.cpp b/models/iaf_psc_exp_multisynapse.cpp index 5fc12fee74..60445392ca 100644 --- a/models/iaf_psc_exp_multisynapse.cpp +++ b/models/iaf_psc_exp_multisynapse.cpp @@ -305,7 +305,7 @@ nest::iaf_psc_exp_multisynapse::pre_run_hook() void iaf_psc_exp_multisynapse::update( const Time& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); // evolve from timestep 'from' to timestep 'to' with steps of h each diff --git a/models/iaf_psc_exp_ps.cpp b/models/iaf_psc_exp_ps.cpp index 751e83b3ae..fdbba30835 100644 --- a/models/iaf_psc_exp_ps.cpp +++ b/models/iaf_psc_exp_ps.cpp @@ -301,7 +301,7 @@ nest::iaf_psc_exp_ps::update( const Time& origin, const long from, const long to // if neuron returns from refractoriness during this step, place // pseudo-event in queue to mark end of refractory period - if ( S_.is_refractory_ && ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) + if ( S_.is_refractory_ and ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) { B_.events_.add_refractory( T, S_.last_spike_offset_ ); } diff --git a/models/iaf_psc_exp_ps_lossless.cpp b/models/iaf_psc_exp_ps_lossless.cpp index afbefc3fea..b71aae7b64 100644 --- a/models/iaf_psc_exp_ps_lossless.cpp +++ b/models/iaf_psc_exp_ps_lossless.cpp @@ -341,7 +341,7 @@ nest::iaf_psc_exp_ps_lossless::update( const Time& origin, const long from, cons // if neuron returns from refractoriness during this step, place // pseudo-event in queue to mark end of refractory period - if ( S_.is_refractory_ && ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) + if ( S_.is_refractory_ and ( T + 1 - S_.last_spike_step_ == V_.refractory_steps_ ) ) { B_.events_.add_refractory( T, S_.last_spike_offset_ ); } diff --git a/models/izhikevich.cpp b/models/izhikevich.cpp index 5dd1710e11..6821013add 100644 --- a/models/izhikevich.cpp +++ b/models/izhikevich.cpp @@ -114,7 +114,7 @@ nest::izhikevich::Parameters_::set( const DictionaryDatum& d, Node* node ) updateValueParam< double >( d, names::d, d_, node ); updateValue< bool >( d, names::consistent_integration, consistent_integration_ ); const double h = Time::get_resolution().get_ms(); - if ( not consistent_integration_ && h != 1.0 ) + if ( not consistent_integration_ and h != 1.0 ) { LOG( M_INFO, "Parameters_::set", "Use 1.0 ms as resolution for consistency." ); } @@ -191,7 +191,7 @@ nest::izhikevich::pre_run_hook() void nest::izhikevich::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const double h = Time::get_resolution().get_ms(); diff --git a/models/mat2_psc_exp.cpp b/models/mat2_psc_exp.cpp index 772c4fc216..3bf8cca57d 100644 --- a/models/mat2_psc_exp.cpp +++ b/models/mat2_psc_exp.cpp @@ -307,7 +307,7 @@ nest::mat2_psc_exp::pre_run_hook() void nest::mat2_psc_exp::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); // evolve from timestep 'from' to timestep 'to' with steps of h each diff --git a/models/multimeter.cpp b/models/multimeter.cpp index 3242ac85e6..28aa313501 100644 --- a/models/multimeter.cpp +++ b/models/multimeter.cpp @@ -107,7 +107,7 @@ void nest::multimeter::Parameters_::set( const DictionaryDatum& d, const Buffers_& b, Node* node ) { if ( b.has_targets_ - && ( d->known( names::interval ) || d->known( names::offset ) || d->known( names::record_from ) ) ) + and ( d->known( names::interval ) || d->known( names::offset ) || d->known( names::record_from ) ) ) { throw BadProperty( "The recording interval, the interval offset and the list of properties " @@ -139,7 +139,7 @@ nest::multimeter::Parameters_::set( const DictionaryDatum& d, const Buffers_& b, { // if offset is different from the default value (0), it must be at least // as large as the resolution - if ( v != 0 && Time( Time::ms( v ) ) < Time::get_resolution() ) + if ( v != 0 and Time( Time::ms( v ) ) < Time::get_resolution() ) { throw BadProperty( "The offset for the sampling interval must be at least as long as the " diff --git a/models/multimeter.h b/models/multimeter.h index fec4383602..109bd8d46c 100644 --- a/models/multimeter.h +++ b/models/multimeter.h @@ -252,7 +252,7 @@ nest::multimeter::set_status( const DictionaryDatum& d ) { // protect multimeter from being frozen bool freeze = false; - if ( updateValue< bool >( d, names::frozen, freeze ) && freeze ) + if ( updateValue< bool >( d, names::frozen, freeze ) and freeze ) { throw BadProperty( "multimeter cannot be frozen." ); } diff --git a/models/music_cont_in_proxy.cpp b/models/music_cont_in_proxy.cpp index 35746d9bf2..b744f0bb44 100644 --- a/models/music_cont_in_proxy.cpp +++ b/models/music_cont_in_proxy.cpp @@ -68,7 +68,7 @@ void nest::music_cont_in_proxy::Parameters_::set( const DictionaryDatum& d, State_& s ) { // TODO: This is not possible, as P_ does not know about get_name() - // if(d->known(names::port_name) && s.published_) + // if(d->known(names::port_name) and s.published_) // throw MUSICPortAlreadyPublished(get_name(), P_.port_name_); if ( not s.published_ ) diff --git a/models/music_cont_out_proxy.cpp b/models/music_cont_out_proxy.cpp index f3c19d5f56..25466e65c1 100644 --- a/models/music_cont_out_proxy.cpp +++ b/models/music_cont_out_proxy.cpp @@ -122,7 +122,7 @@ nest::music_cont_out_proxy::Parameters_::set( const DictionaryDatum& d, updateValue< string >( d, names::port_name, port_name_ ); } - if ( buffers.has_targets_ && ( d->known( names::interval ) || d->known( names::record_from ) ) ) + if ( buffers.has_targets_ and ( d->known( names::interval ) || d->known( names::record_from ) ) ) { throw BadProperty( "The recording interval and the list of properties to record " diff --git a/models/music_event_out_proxy.cpp b/models/music_event_out_proxy.cpp index 4e763f4326..52a24a45a7 100644 --- a/models/music_event_out_proxy.cpp +++ b/models/music_event_out_proxy.cpp @@ -70,7 +70,7 @@ void nest::music_event_out_proxy::Parameters_::set( const DictionaryDatum& d, State_& s ) { // TODO: This is not possible, as P_ does not know about get_name() - // if(d->known(names::port_name) && s.published_) + // if(d->known(names::port_name) and s.published_) // throw MUSICPortAlreadyPublished(get_name(), P_.port_name_); if ( not s.published_ ) diff --git a/models/music_rate_in_proxy.cpp b/models/music_rate_in_proxy.cpp index 355f370a56..4ede7f56a6 100644 --- a/models/music_rate_in_proxy.cpp +++ b/models/music_rate_in_proxy.cpp @@ -68,7 +68,7 @@ void nest::music_rate_in_proxy::Parameters_::set( const DictionaryDatum& d, State_& s ) { // TODO: This is not possible, as P_ does not know about get_name() - // if(d->known(names::port_name) && s.registered_) + // if(d->known(names::port_name) and s.registered_) // throw MUSICPortAlreadyPublished(get_name(), P_.port_name_); if ( not s.registered_ ) diff --git a/models/music_rate_out_proxy.cpp b/models/music_rate_out_proxy.cpp index 1006126aab..c9ded0acd1 100644 --- a/models/music_rate_out_proxy.cpp +++ b/models/music_rate_out_proxy.cpp @@ -80,7 +80,7 @@ void nest::music_rate_out_proxy::Parameters_::set( const DictionaryDatum& d, State_& s ) { // TODO: This is not possible, as P_ does not know about get_name() - // if(d->known(names::port_name) && s.published_) + // if(d->known(names::port_name) and s.published_) // throw MUSICPortAlreadyPublished(get_name(), P_.port_name_); if ( not s.published_ ) diff --git a/models/noise_generator.cpp b/models/noise_generator.cpp index 6792064db9..ff18fdd792 100644 --- a/models/noise_generator.cpp +++ b/models/noise_generator.cpp @@ -289,7 +289,7 @@ nest::noise_generator::send_test_event( Node& target, rport receptor_type, synin void nest::noise_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const long start = origin.get_steps(); @@ -347,7 +347,7 @@ nest::noise_generator::event_hook( DSCurrentEvent& e ) const port prt = e.get_port(); // we handle only one port here, get reference to vector elem - assert( 0 <= prt && static_cast< size_t >( prt ) < B_.amps_.size() ); + assert( 0 <= prt and static_cast< size_t >( prt ) < B_.amps_.size() ); e.set_current( B_.amps_[ prt ] ); e.get_receiver().handle( e ); diff --git a/models/parrot_neuron.cpp b/models/parrot_neuron.cpp index fd6962372a..c3e7747d2c 100644 --- a/models/parrot_neuron.cpp +++ b/models/parrot_neuron.cpp @@ -58,7 +58,7 @@ parrot_neuron::init_buffers_() void parrot_neuron::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/poisson_generator.cpp b/models/poisson_generator.cpp index 0a6d96c485..00de605b42 100644 --- a/models/poisson_generator.cpp +++ b/models/poisson_generator.cpp @@ -117,7 +117,7 @@ nest::poisson_generator::pre_run_hook() void nest::poisson_generator::update( Time const& T, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); if ( P_.rate_ <= 0 ) diff --git a/models/poisson_generator_ps.cpp b/models/poisson_generator_ps.cpp index 412673e36d..adc9bded56 100644 --- a/models/poisson_generator_ps.cpp +++ b/models/poisson_generator_ps.cpp @@ -178,7 +178,7 @@ nest::poisson_generator_ps::pre_run_hook() void nest::poisson_generator_ps::update( Time const& T, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) @@ -213,7 +213,7 @@ nest::poisson_generator_ps::event_hook( DSSpikeEvent& e ) const port prt = e.get_port(); // we handle only one port here, get reference to vector elem - assert( 0 <= prt && static_cast< size_t >( prt ) < B_.next_spike_.size() ); + assert( 0 <= prt and static_cast< size_t >( prt ) < B_.next_spike_.size() ); // obtain rng RngPtr rng = get_vp_specific_rng( get_thread() ); diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index ffa7a7a14b..682f3e6c0f 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -578,7 +578,7 @@ void nest::pp_cond_exp_mc_urbanczik::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -699,7 +699,7 @@ void nest::pp_cond_exp_mc_urbanczik::handle( SpikeEvent& e ) { assert( e.get_delay_steps() > 0 ); - assert( 0 <= e.get_rport() && e.get_rport() < 2 * NCOMP ); + assert( 0 <= e.get_rport() and e.get_rport() < 2 * NCOMP ); B_.spikes_[ e.get_rport() ].add_value( e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ), e.get_weight() * e.get_multiplicity() ); @@ -710,7 +710,7 @@ nest::pp_cond_exp_mc_urbanczik::handle( CurrentEvent& e ) { assert( e.get_delay_steps() > 0 ); // not 100% clean, should look at MIN, SUP - assert( 0 <= e.get_rport() && e.get_rport() < NCOMP ); + assert( 0 <= e.get_rport() and e.get_rport() < NCOMP ); // add weighted current; HEP 2002-10-04 B_.currents_[ e.get_rport() ].add_value( diff --git a/models/pp_cond_exp_mc_urbanczik.h b/models/pp_cond_exp_mc_urbanczik.h index 8a640610cc..0a69b64aa5 100644 --- a/models/pp_cond_exp_mc_urbanczik.h +++ b/models/pp_cond_exp_mc_urbanczik.h @@ -557,9 +557,9 @@ pp_cond_exp_mc_urbanczik::send_test_event( Node& target, rport receptor_type, sy inline port pp_cond_exp_mc_urbanczik::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type < MIN_SPIKE_RECEPTOR || receptor_type >= SUP_SPIKE_RECEPTOR ) + if ( receptor_type < MIN_SPIKE_RECEPTOR or receptor_type >= SUP_SPIKE_RECEPTOR ) { - if ( receptor_type < 0 || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < 0 or receptor_type >= SUP_CURR_RECEPTOR ) { throw UnknownReceptorType( receptor_type, get_name() ); } @@ -574,9 +574,9 @@ pp_cond_exp_mc_urbanczik::handles_test_event( SpikeEvent&, rport receptor_type ) inline port pp_cond_exp_mc_urbanczik::handles_test_event( CurrentEvent&, rport receptor_type ) { - if ( receptor_type < MIN_CURR_RECEPTOR || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < MIN_CURR_RECEPTOR or receptor_type >= SUP_CURR_RECEPTOR ) { - if ( receptor_type >= 0 && receptor_type < MIN_CURR_RECEPTOR ) + if ( receptor_type >= 0 and receptor_type < MIN_CURR_RECEPTOR ) { throw IncompatibleReceptorType( receptor_type, get_name(), "CurrentEvent" ); } @@ -593,7 +593,7 @@ pp_cond_exp_mc_urbanczik::handles_test_event( DataLoggingRequest& dlr, rport rec { if ( receptor_type != 0 ) { - if ( receptor_type < 0 || receptor_type >= SUP_CURR_RECEPTOR ) + if ( receptor_type < 0 or receptor_type >= SUP_CURR_RECEPTOR ) { throw UnknownReceptorType( receptor_type, get_name() ); } diff --git a/models/pp_psc_delta.cpp b/models/pp_psc_delta.cpp index a89354e025..8c532a8325 100644 --- a/models/pp_psc_delta.cpp +++ b/models/pp_psc_delta.cpp @@ -301,7 +301,7 @@ nest::pp_psc_delta::pre_run_hook() V_.P33_ = std::exp( -V_.h_ / P_.tau_m_ ); V_.P30_ = 1 / P_.c_m_ * ( 1 - V_.P33_ ) * P_.tau_m_; - if ( P_.dead_time_ != 0 && P_.dead_time_ < V_.h_ ) + if ( P_.dead_time_ != 0 and P_.dead_time_ < V_.h_ ) { P_.dead_time_ = V_.h_; } @@ -361,7 +361,7 @@ void nest::pp_psc_delta::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) diff --git a/models/ppd_sup_generator.cpp b/models/ppd_sup_generator.cpp index 3cabd68eff..4ae9416d28 100644 --- a/models/ppd_sup_generator.cpp +++ b/models/ppd_sup_generator.cpp @@ -69,7 +69,7 @@ nest::ppd_sup_generator::Age_distribution_::update( double hazard_step, RngPtr r of thumb, this approximation is good if n >= 20 and p <= 0.05, or if n >= 100 and np <= 10. Source: http://en.wikipedia.org/wiki/Binomial_distribution#Poisson_approximation */ - if ( ( occ_active_ >= 100 && hazard_step <= 0.01 ) || ( occ_active_ >= 500 && hazard_step * occ_active_ <= 0.1 ) ) + if ( ( occ_active_ >= 100 and hazard_step <= 0.01 ) || ( occ_active_ >= 500 and hazard_step * occ_active_ <= 0.1 ) ) { poisson_distribution::param_type param( hazard_step * occ_active_ ); n_spikes = poisson_dist_( rng, param ); @@ -231,7 +231,7 @@ nest::ppd_sup_generator::pre_run_hook() void nest::ppd_sup_generator::update( Time const& T, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) @@ -249,7 +249,7 @@ nest::ppd_sup_generator::update( Time const& T, const long from, const long to ) } // get current (time-dependent) hazard rate and store it. - if ( P_.amplitude_ > 0.0 && ( P_.frequency_ > 0.0 || P_.frequency_ < 0.0 ) ) + if ( P_.amplitude_ > 0.0 and ( P_.frequency_ > 0.0 || P_.frequency_ < 0.0 ) ) { double t_ms = t.get_ms(); V_.hazard_step_t_ = V_.hazard_step_ * ( 1.0 + P_.amplitude_ * std::sin( V_.omega_ * t_ms ) ); @@ -272,7 +272,7 @@ nest::ppd_sup_generator::event_hook( DSSpikeEvent& e ) const port prt = e.get_port(); // we handle only one port here, get reference to vector element - assert( 0 <= prt && static_cast< size_t >( prt ) < B_.age_distributions_.size() ); + assert( 0 <= prt and static_cast< size_t >( prt ) < B_.age_distributions_.size() ); // age_distribution object propagates one time step and returns number of // spikes diff --git a/models/rate_neuron_ipn_impl.h b/models/rate_neuron_ipn_impl.h index 2f316281dd..42b13a1d06 100644 --- a/models/rate_neuron_ipn_impl.h +++ b/models/rate_neuron_ipn_impl.h @@ -270,7 +270,7 @@ nest::rate_neuron_ipn< TNonlinearities >::update_( Time const& origin, const long to, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t buffer_size = kernel().connection_manager.get_min_delay(); diff --git a/models/rate_neuron_opn_impl.h b/models/rate_neuron_opn_impl.h index 13aa05b39f..409a5924d1 100644 --- a/models/rate_neuron_opn_impl.h +++ b/models/rate_neuron_opn_impl.h @@ -246,7 +246,7 @@ nest::rate_neuron_opn< TNonlinearities >::update_( Time const& origin, const long to, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t buffer_size = kernel().connection_manager.get_min_delay(); diff --git a/models/rate_transformer_node_impl.h b/models/rate_transformer_node_impl.h index 715b2a91c5..1b971dab90 100644 --- a/models/rate_transformer_node_impl.h +++ b/models/rate_transformer_node_impl.h @@ -181,7 +181,7 @@ nest::rate_transformer_node< TNonlinearities >::update_( Time const& origin, const long to, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t buffer_size = kernel().connection_manager.get_min_delay(); diff --git a/models/siegert_neuron.cpp b/models/siegert_neuron.cpp index 7fd0a31543..d2c05e0e4c 100644 --- a/models/siegert_neuron.cpp +++ b/models/siegert_neuron.cpp @@ -310,7 +310,7 @@ nest::siegert_neuron::pre_run_hook() bool nest::siegert_neuron::update_( Time const& origin, const long from, const long to, const bool called_from_wfr_update ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const size_t buffer_size = kernel().connection_manager.get_min_delay(); diff --git a/models/sinusoidal_gamma_generator.cpp b/models/sinusoidal_gamma_generator.cpp index 08c29220d5..44178fd407 100644 --- a/models/sinusoidal_gamma_generator.cpp +++ b/models/sinusoidal_gamma_generator.cpp @@ -144,7 +144,7 @@ nest::sinusoidal_gamma_generator::Parameters_::set( const DictionaryDatum& d, const sinusoidal_gamma_generator& n, Node* node ) { - if ( not n.is_model_prototype() && d->known( names::individual_spike_trains ) ) + if ( not n.is_model_prototype() and d->known( names::individual_spike_trains ) ) { throw BadProperty( "The individual_spike_trains property can only be set as" @@ -259,7 +259,7 @@ nest::sinusoidal_gamma_generator::deltaLambda_( const Parameters_& p, double t_a } double deltaLambda = p.order_ * p.rate_ * ( t_b - t_a ); - if ( std::abs( p.amplitude_ ) > 0 && std::abs( p.om_ ) > 0 ) + if ( std::abs( p.amplitude_ ) > 0 and std::abs( p.om_ ) > 0 ) { deltaLambda += -p.order_ * p.amplitude_ / p.om_ * ( std::cos( p.om_ * t_b + p.phi_ ) - std::cos( p.om_ * t_a + p.phi_ ) ); @@ -309,7 +309,7 @@ nest::sinusoidal_gamma_generator::hazard_( port tgt_idx ) const void nest::sinusoidal_gamma_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); for ( long lag = from; lag < to; ++lag ) @@ -348,7 +348,7 @@ nest::sinusoidal_gamma_generator::event_hook( DSSpikeEvent& e ) { // get port number --- see #737 const port tgt_idx = e.get_port(); - assert( 0 <= tgt_idx && static_cast< size_t >( tgt_idx ) < B_.t0_ms_.size() ); + assert( 0 <= tgt_idx and static_cast< size_t >( tgt_idx ) < B_.t0_ms_.size() ); if ( V_.rng_->drand() < hazard_( tgt_idx ) ) { diff --git a/models/sinusoidal_poisson_generator.cpp b/models/sinusoidal_poisson_generator.cpp index deec0ea17c..f1e7c1833c 100644 --- a/models/sinusoidal_poisson_generator.cpp +++ b/models/sinusoidal_poisson_generator.cpp @@ -141,7 +141,7 @@ nest::sinusoidal_poisson_generator::Parameters_::set( const DictionaryDatum& d, const sinusoidal_poisson_generator& n, Node* node ) { - if ( not n.is_model_prototype() && d->known( names::individual_spike_trains ) ) + if ( not n.is_model_prototype() and d->known( names::individual_spike_trains ) ) { throw BadProperty( "The individual_spike_trains property can only be set as" @@ -232,7 +232,7 @@ nest::sinusoidal_poisson_generator::pre_run_hook() void nest::sinusoidal_poisson_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); const long start = origin.get_steps(); diff --git a/models/spike_generator.cpp b/models/spike_generator.cpp index 8878a38d16..24fd65e348 100644 --- a/models/spike_generator.cpp +++ b/models/spike_generator.cpp @@ -68,7 +68,7 @@ nest::spike_generator::Parameters_::get( DictionaryDatum& d ) const const size_t n_spikes = spike_stamps_.size(); const size_t n_offsets = spike_offsets_.size(); - assert( ( precise_times_ && n_offsets == n_spikes ) || ( not precise_times_ && n_offsets == 0 ) ); + assert( ( precise_times_ and n_offsets == n_spikes ) || ( not precise_times_ and n_offsets == 0 ) ); auto* times_ms = new std::vector< double >(); times_ms->reserve( n_spikes ); @@ -91,7 +91,7 @@ nest::spike_generator::Parameters_::get( DictionaryDatum& d ) const void nest::spike_generator::Parameters_::assert_valid_spike_time_and_insert_( double t, const Time& origin, const Time& now ) { - if ( t == 0.0 && not shift_now_spikes_ ) + if ( t == 0.0 and not shift_now_spikes_ ) { throw BadProperty( "spike time cannot be set to 0." ); } @@ -124,7 +124,7 @@ nest::spike_generator::Parameters_::assert_valid_spike_time_and_insert_( double } assert( t_spike.is_grid_time() ); - if ( origin + t_spike == now && shift_now_spikes_ ) + if ( origin + t_spike == now and shift_now_spikes_ ) { t_spike.advance(); } @@ -165,7 +165,7 @@ nest::spike_generator::Parameters_::set( const DictionaryDatum& d, bool allow_offgrid_times_changed = updateValueParam< bool >( d, names::allow_offgrid_times, allow_offgrid_times_, node ); bool flags_changed = precise_times_changed or shift_now_spikes_changed or allow_offgrid_times_changed; - if ( precise_times_ && ( allow_offgrid_times_ || shift_now_spikes_ ) ) + if ( precise_times_ and ( allow_offgrid_times_ || shift_now_spikes_ ) ) { throw BadProperty( "Option precise_times cannot be set to true when either " @@ -173,7 +173,7 @@ nest::spike_generator::Parameters_::set( const DictionaryDatum& d, } const bool updated_spike_times = d->known( names::spike_times ); - if ( flags_changed && not( updated_spike_times || spike_stamps_.empty() ) ) + if ( flags_changed and not( updated_spike_times || spike_stamps_.empty() ) ) { throw BadProperty( "Options can only be set together with spike times or if no " diff --git a/models/spin_detector.cpp b/models/spin_detector.cpp index 7740a585b1..49b54f3929 100644 --- a/models/spin_detector.cpp +++ b/models/spin_detector.cpp @@ -134,7 +134,7 @@ nest::spin_detector::handle( SpikeEvent& e ) long m = e.get_multiplicity(); index node_id = e.get_sender_node_id(); const Time& t_spike = e.get_stamp(); - if ( m == 1 && node_id == last_in_node_id_ && t_spike == t_last_in_spike_ ) + if ( m == 1 and node_id == last_in_node_id_ and t_spike == t_last_in_spike_ ) { // received twice the same node ID, so transition 0->1 // revise the last event diff --git a/models/stdp_dopamine_synapse.h b/models/stdp_dopamine_synapse.h index 7862dfe4d9..191192d639 100644 --- a/models/stdp_dopamine_synapse.h +++ b/models/stdp_dopamine_synapse.h @@ -458,7 +458,7 @@ stdp_dopamine_synapse< targetidentifierT >::process_dopa_spikes_( const std::vec // process dopa spikes in (t0, t1] // propagate weight from t0 to t1 if ( ( dopa_spikes.size() > dopa_spikes_idx_ + 1 ) - && ( t1 - dopa_spikes[ dopa_spikes_idx_ + 1 ].spike_time_ > -1.0 * kernel().connection_manager.get_stdp_eps() ) ) + and ( t1 - dopa_spikes[ dopa_spikes_idx_ + 1 ].spike_time_ > -1.0 * kernel().connection_manager.get_stdp_eps() ) ) { // there is at least 1 dopa spike in (t0, t1] // propagate weight up to first dopa spike and update dopamine trace @@ -472,7 +472,7 @@ stdp_dopamine_synapse< targetidentifierT >::process_dopa_spikes_( const std::vec // process remaining dopa spikes in (t0, t1] double cd; while ( ( dopa_spikes.size() > dopa_spikes_idx_ + 1 ) - && ( t1 - dopa_spikes[ dopa_spikes_idx_ + 1 ].spike_time_ > -1.0 * kernel().connection_manager.get_stdp_eps() ) ) + and ( t1 - dopa_spikes[ dopa_spikes_idx_ + 1 ].spike_time_ > -1.0 * kernel().connection_manager.get_stdp_eps() ) ) { // propagate weight up to next dopa spike and update dopamine trace // weight and dopamine trace n are at time of last dopa spike td but diff --git a/models/stdp_synapse_facetshw_hom.h b/models/stdp_synapse_facetshw_hom.h index 674af88b43..b949e1b927 100644 --- a/models/stdp_synapse_facetshw_hom.h +++ b/models/stdp_synapse_facetshw_hom.h @@ -433,7 +433,7 @@ stdp_facetshw_synapse_hom< targetidentifierT >::send( Event& e, bool eval_1 = eval_function_( a_causal_, a_acausal_, a_thresh_th_, a_thresh_tl_, cp.configbit_1_ ); // select LUT, update weight and reset capacitors - if ( eval_0 == true && eval_1 == false ) + if ( eval_0 == true and eval_1 == false ) { discrete_weight_ = lookup_( discrete_weight_, cp.lookuptable_0_ ); if ( cp.reset_pattern_[ 0 ] ) @@ -445,7 +445,7 @@ stdp_facetshw_synapse_hom< targetidentifierT >::send( Event& e, a_acausal_ = 0; } } - else if ( eval_0 == false && eval_1 == true ) + else if ( eval_0 == false and eval_1 == true ) { discrete_weight_ = lookup_( discrete_weight_, cp.lookuptable_1_ ); if ( cp.reset_pattern_[ 2 ] ) @@ -457,7 +457,7 @@ stdp_facetshw_synapse_hom< targetidentifierT >::send( Event& e, a_acausal_ = 0; } } - else if ( eval_0 == true && eval_1 == true ) + else if ( eval_0 == true and eval_1 == true ) { discrete_weight_ = lookup_( discrete_weight_, cp.lookuptable_2_ ); if ( cp.reset_pattern_[ 4 ] ) diff --git a/models/stdp_synapse_facetshw_hom_impl.h b/models/stdp_synapse_facetshw_hom_impl.h index 76da53a759..3d5b7673eb 100644 --- a/models/stdp_synapse_facetshw_hom_impl.h +++ b/models/stdp_synapse_facetshw_hom_impl.h @@ -192,7 +192,7 @@ STDPFACETSHWHomCommonProperties< targetidentifierT >::set_status( const Dictiona // are look-up table entries out of bounds? for ( size_t i = 0; i < size_t( lookuptable_0_.size() ); ++i ) { - if ( ( lookuptable_0_[ i ] < 0 ) || ( lookuptable_0_[ i ] > 15 ) ) + if ( ( lookuptable_0_[ i ] < 0 ) or ( lookuptable_0_[ i ] > 15 ) ) { throw BadProperty( "Look-up table entries must be integers in [0,15]" ); } @@ -211,7 +211,7 @@ STDPFACETSHWHomCommonProperties< targetidentifierT >::set_status( const Dictiona // are look-up table entries out of bounds? for ( size_t i = 0; i < size_t( lookuptable_1_.size() ); ++i ) { - if ( ( lookuptable_1_[ i ] < 0 ) || ( lookuptable_1_[ i ] > 15 ) ) + if ( ( lookuptable_1_[ i ] < 0 ) or ( lookuptable_1_[ i ] > 15 ) ) { throw BadProperty( "Look-up table entries must be integers in [0,15]" ); } @@ -230,7 +230,7 @@ STDPFACETSHWHomCommonProperties< targetidentifierT >::set_status( const Dictiona // are look-up table entries out of bounds? for ( size_t i = 0; i < size_t( lookuptable_2_.size() ); ++i ) { - if ( ( lookuptable_2_[ i ] < 0 ) || ( lookuptable_2_[ i ] > 15 ) ) + if ( ( lookuptable_2_[ i ] < 0 ) or ( lookuptable_2_[ i ] > 15 ) ) { throw BadProperty( "Look-up table entries must be integers in [0,15]" ); } diff --git a/models/step_current_generator.cpp b/models/step_current_generator.cpp index 086907042b..e4b29d51ca 100644 --- a/models/step_current_generator.cpp +++ b/models/step_current_generator.cpp @@ -272,7 +272,7 @@ nest::step_current_generator::pre_run_hook() void nest::step_current_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( P_.amp_time_stamps_.size() == P_.amp_values_.size() ); @@ -282,7 +282,7 @@ nest::step_current_generator::update( Time const& origin, const long from, const // Skip any times in the past. Since we must send events proactively, // idx_ must point to times in the future. const long first = t0 + from; - while ( B_.idx_ < P_.amp_time_stamps_.size() && P_.amp_time_stamps_[ B_.idx_ ].get_steps() <= first ) + while ( B_.idx_ < P_.amp_time_stamps_.size() and P_.amp_time_stamps_[ B_.idx_ ].get_steps() <= first ) { ++B_.idx_; } @@ -296,7 +296,7 @@ nest::step_current_generator::update( Time const& origin, const long from, const // Keep the amplitude up-to-date at all times. // We need to change the amplitude one step ahead of time, see comment // on class SimulatingDevice. - if ( B_.idx_ < P_.amp_time_stamps_.size() && curr_time + 1 == P_.amp_time_stamps_[ B_.idx_ ].get_steps() ) + if ( B_.idx_ < P_.amp_time_stamps_.size() and curr_time + 1 == P_.amp_time_stamps_[ B_.idx_ ].get_steps() ) { B_.amp_ = P_.amp_values_[ B_.idx_ ]; B_.idx_++; diff --git a/models/step_rate_generator.cpp b/models/step_rate_generator.cpp index f5e7135284..2cd309aa9d 100644 --- a/models/step_rate_generator.cpp +++ b/models/step_rate_generator.cpp @@ -273,7 +273,7 @@ nest::step_rate_generator::pre_run_hook() void nest::step_rate_generator::update( Time const& origin, const long from, const long to ) { - assert( to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() ); + assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); assert( P_.amp_time_stamps_.size() == P_.amp_values_.size() ); @@ -287,7 +287,7 @@ nest::step_rate_generator::update( Time const& origin, const long from, const lo // Skip any times in the past. Since we must send events proactively, // idx_ must point to times in the future. const long first = t0 + from; - while ( B_.idx_ < P_.amp_time_stamps_.size() && P_.amp_time_stamps_[ B_.idx_ ].get_steps() <= first ) + while ( B_.idx_ < P_.amp_time_stamps_.size() and P_.amp_time_stamps_[ B_.idx_ ].get_steps() <= first ) { ++B_.idx_; } @@ -302,7 +302,7 @@ nest::step_rate_generator::update( Time const& origin, const long from, const lo // Keep the amplitude up-to-date at all times. // We need to change the amplitude one step ahead of time, see comment // on class SimulatingDevice. - if ( B_.idx_ < P_.amp_time_stamps_.size() && curr_time + 1 == P_.amp_time_stamps_[ B_.idx_ ].get_steps() ) + if ( B_.idx_ < P_.amp_time_stamps_.size() and curr_time + 1 == P_.amp_time_stamps_[ B_.idx_ ].get_steps() ) { B_.amp_ = P_.amp_values_[ B_.idx_ ]; B_.idx_++; diff --git a/models/tsodyks2_synapse.h b/models/tsodyks2_synapse.h index 4cda0ada97..08cedf5c73 100644 --- a/models/tsodyks2_synapse.h +++ b/models/tsodyks2_synapse.h @@ -270,13 +270,13 @@ tsodyks2_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Con updateValue< double >( d, names::weight, weight_ ); updateValue< double >( d, names::dU, U_ ); - if ( U_ > 1.0 || U_ < 0.0 ) + if ( U_ > 1.0 or U_ < 0.0 ) { throw BadProperty( "U must be in [0,1]." ); } updateValue< double >( d, names::u, u_ ); - if ( u_ > 1.0 || u_ < 0.0 ) + if ( u_ > 1.0 or u_ < 0.0 ) { throw BadProperty( "u must be in [0,1]." ); } diff --git a/models/tsodyks_synapse.h b/models/tsodyks_synapse.h index f92dd058f3..404678e543 100644 --- a/models/tsodyks_synapse.h +++ b/models/tsodyks_synapse.h @@ -336,7 +336,7 @@ tsodyks_synapse< targetidentifierT >::set_status( const DictionaryDatum& d, Conn updateValue< double >( d, names::weight, weight_ ); updateValue< double >( d, names::U, U_ ); - if ( U_ > 1.0 || U_ < 0.0 ) + if ( U_ > 1.0 or U_ < 0.0 ) { throw BadProperty( "U must be in [0,1]." ); } diff --git a/nestkernel/clopath_archiving_node.cpp b/nestkernel/clopath_archiving_node.cpp index 4617c78829..66c6f221fa 100644 --- a/nestkernel/clopath_archiving_node.cpp +++ b/nestkernel/clopath_archiving_node.cpp @@ -173,12 +173,12 @@ nest::ClopathArchivingNode::get_LTP_history( double t1, // To have a well defined discretization of the integral, we make sure // that we exclude the entry at t1 but include the one at t2 by subtracting // a small number so that runner->t_ is never equal to t1 or t2. - while ( ( runner != ltp_history_.end() ) && ( runner->t_ - 1.0e-6 < t1 ) ) + while ( ( runner != ltp_history_.end() ) and ( runner->t_ - 1.0e-6 < t1 ) ) { ++runner; } *start = runner; - while ( ( runner != ltp_history_.end() ) && ( runner->t_ - 1.0e-6 < t2 ) ) + while ( ( runner != ltp_history_.end() ) and ( runner->t_ - 1.0e-6 < t2 ) ) { ( runner->access_counter_ )++; ++runner; @@ -209,7 +209,7 @@ nest::ClopathArchivingNode::write_clopath_history( Time const& t_sp, double del_u_bar_minus = delayed_u_bar_minus_[ delayed_u_bars_idx_ ]; // save data for Clopath STDP if necessary - if ( ( u > theta_plus_ ) && ( del_u_bar_plus > theta_minus_ ) ) + if ( ( u > theta_plus_ ) and ( del_u_bar_plus > theta_minus_ ) ) { write_LTP_history( t_ms, u, del_u_bar_plus ); } diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index 53ed61be8c..af985d087c 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -1462,7 +1462,7 @@ nest::ConnectionManager::connection_required( Node*& source, Node*& target, thre const bool target_vp_local = kernel().vp_manager.is_local_vp( target_vp ); const thread target_thread = kernel().vp_manager.vp_to_thread( target_vp ); - if ( target_vp_local && target_thread == tid ) + if ( target_vp_local and target_thread == tid ) { const index source_node_id = source->get_node_id(); source = kernel().node_manager.get_node_or_proxy( source_node_id, target_thread ); diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index 752f4193bc..b24be48749 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -1211,7 +1211,7 @@ class BackendPrepared : public KernelException { } - BackendPrepared( std::string&& backend ) + BackendPrepared( std::stringand backend ) : backend_( std::move( backend ) ) { } diff --git a/nestkernel/grid_layer.h b/nestkernel/grid_layer.h index 3e52554687..54408747f8 100644 --- a/nestkernel/grid_layer.h +++ b/nestkernel/grid_layer.h @@ -88,12 +88,12 @@ class GridLayer : public Layer< D > bool operator==( const masked_iterator& other ) const { - return ( other.layer_.get_metadata() == layer_.get_metadata() ) && ( other.node_ == node_ ); + return ( other.layer_.get_metadata() == layer_.get_metadata() ) and ( other.node_ == node_ ); } bool operator!=( const masked_iterator& other ) const { - return ( other.layer_.get_metadata() != layer_.get_metadata() ) || ( other.node_ != node_ ); + return ( other.layer_.get_metadata() != layer_.get_metadata() ) or ( other.node_ != node_ ); } protected: diff --git a/nestkernel/mask.cpp b/nestkernel/mask.cpp index b2ecf943a0..a0227396d3 100644 --- a/nestkernel/mask.cpp +++ b/nestkernel/mask.cpp @@ -280,7 +280,7 @@ BoxMask< 2 >::inside( const Position< 2 >& p ) const // If the box is not rotated we just check if the point is inside the box. if ( not is_rotated_ ) { - return ( lower_left_ <= p ) && ( p <= upper_right_ ); + return ( lower_left_ <= p ) and ( p <= upper_right_ ); } // If we have a rotated box, we rotate the point down to the unrotated box, @@ -297,7 +297,7 @@ BoxMask< 2 >::inside( const Position< 2 >& p ) const const Position< 2 > new_p( new_x, new_y ); // We need to add a small epsilon in case of rounding errors. - return ( lower_left_ - eps_ <= new_p ) && ( new_p <= upper_right_ + eps_ ); + return ( lower_left_ - eps_ <= new_p ) and ( new_p <= upper_right_ + eps_ ); } template <> @@ -307,7 +307,7 @@ BoxMask< 3 >::inside( const Position< 3 >& p ) const // If the box is not rotated we just check if the point is inside the box. if ( not is_rotated_ ) { - return ( lower_left_ <= p ) && ( p <= upper_right_ ); + return ( lower_left_ <= p ) and ( p <= upper_right_ ); } // If we have a rotated box, we rotate the point down to the unrotated box, @@ -330,7 +330,7 @@ BoxMask< 3 >::inside( const Position< 3 >& p ) const const Position< 3 > new_p( new_x, new_y, new_z ); // We need to add a small epsilon in case of rounding errors. - return ( lower_left_ - eps_ <= new_p ) && ( new_p <= upper_right_ + eps_ ); + return ( lower_left_ - eps_ <= new_p ) and ( new_p <= upper_right_ + eps_ ); } template <> diff --git a/nestkernel/mask_impl.h b/nestkernel/mask_impl.h index 2736ab2331..b3b2f61ef7 100644 --- a/nestkernel/mask_impl.h +++ b/nestkernel/mask_impl.h @@ -78,7 +78,7 @@ Mask< D >::outside( const Box< D >& b ) const Box< D > bb = get_bbox(); for ( int i = 0; i < D; ++i ) { - if ( ( b.upper_right[ i ] < bb.lower_left[ i ] ) || ( b.lower_left[ i ] > bb.upper_right[ i ] ) ) + if ( ( b.upper_right[ i ] < bb.lower_left[ i ] ) or ( b.lower_left[ i ] > bb.upper_right[ i ] ) ) { return true; } @@ -105,7 +105,7 @@ BoxMask< D >::outside( const Box< D >& b ) const // so we don't know if it is an actual problem. for ( int i = 0; i < D; ++i ) { - if ( ( b.upper_right[ i ] < min_values_[ i ] ) || ( b.lower_left[ i ] > max_values_[ i ] ) ) + if ( ( b.upper_right[ i ] < min_values_[ i ] ) or ( b.lower_left[ i ] > max_values_[ i ] ) ) { return true; } @@ -175,7 +175,7 @@ BallMask< D >::outside( const Box< D >& b ) const // the ball. This could be made more refined. for ( int i = 0; i < D; ++i ) { - if ( ( b.upper_right[ i ] < center_[ i ] - radius_ ) || ( b.lower_left[ i ] > center_[ i ] + radius_ ) ) + if ( ( b.upper_right[ i ] < center_[ i ] - radius_ ) or ( b.lower_left[ i ] > center_[ i ] + radius_ ) ) { return true; } @@ -259,7 +259,7 @@ EllipseMask< D >::outside( const Box< D >& b ) const for ( int i = 0; i < D; ++i ) { - if ( ( b.upper_right[ i ] < bb.lower_left[ i ] ) || ( b.lower_left[ i ] > bb.upper_right[ i ] ) ) + if ( ( b.upper_right[ i ] < bb.lower_left[ i ] ) or ( b.lower_left[ i ] > bb.upper_right[ i ] ) ) { return true; } @@ -302,21 +302,21 @@ template < int D > bool IntersectionMask< D >::inside( const Position< D >& p ) const { - return mask1_->inside( p ) && mask2_->inside( p ); + return mask1_->inside( p ) and mask2_->inside( p ); } template < int D > bool IntersectionMask< D >::inside( const Box< D >& b ) const { - return mask1_->inside( b ) && mask2_->inside( b ); + return mask1_->inside( b ) and mask2_->inside( b ); } template < int D > bool IntersectionMask< D >::outside( const Box< D >& b ) const { - return mask1_->outside( b ) || mask2_->outside( b ); + return mask1_->outside( b ) or mask2_->outside( b ); } template < int D > @@ -350,21 +350,21 @@ template < int D > bool UnionMask< D >::inside( const Position< D >& p ) const { - return mask1_->inside( p ) || mask2_->inside( p ); + return mask1_->inside( p ) or mask2_->inside( p ); } template < int D > bool UnionMask< D >::inside( const Box< D >& b ) const { - return mask1_->inside( b ) || mask2_->inside( b ); + return mask1_->inside( b ) or mask2_->inside( b ); } template < int D > bool UnionMask< D >::outside( const Box< D >& b ) const { - return mask1_->outside( b ) && mask2_->outside( b ); + return mask1_->outside( b ) and mask2_->outside( b ); } template < int D > @@ -398,21 +398,21 @@ template < int D > bool DifferenceMask< D >::inside( const Position< D >& p ) const { - return mask1_->inside( p ) && not mask2_->inside( p ); + return mask1_->inside( p ) and not mask2_->inside( p ); } template < int D > bool DifferenceMask< D >::inside( const Box< D >& b ) const { - return mask1_->inside( b ) && mask2_->outside( b ); + return mask1_->inside( b ) and mask2_->outside( b ); } template < int D > bool DifferenceMask< D >::outside( const Box< D >& b ) const { - return mask1_->outside( b ) || mask2_->inside( b ); + return mask1_->outside( b ) or mask2_->inside( b ); } template < int D > diff --git a/nestkernel/ntree.h b/nestkernel/ntree.h index 6713c2417a..2a687e4b8a 100644 --- a/nestkernel/ntree.h +++ b/nestkernel/ntree.h @@ -125,12 +125,12 @@ class Ntree bool operator==( const iterator& other ) const { - return ( other.ntree_ == ntree_ ) && ( other.node_ == node_ ); + return ( other.ntree_ == ntree_ ) and ( other.node_ == node_ ); } bool operator!=( const iterator& other ) const { - return ( other.ntree_ != ntree_ ) || ( other.node_ != node_ ); + return ( other.ntree_ != ntree_ ) or ( other.node_ != node_ ); } protected: @@ -210,12 +210,12 @@ class Ntree bool operator==( const masked_iterator& other ) const { - return ( other.ntree_ == ntree_ ) && ( other.node_ == node_ ); + return ( other.ntree_ == ntree_ ) and ( other.node_ == node_ ); } bool operator!=( const masked_iterator& other ) const { - return ( other.ntree_ != ntree_ ) || ( other.node_ != node_ ); + return ( other.ntree_ != ntree_ ) or ( other.node_ != node_ ); } protected: diff --git a/nestkernel/ntree_impl.h b/nestkernel/ntree_impl.h index 42400f29f4..33dcaba4db 100644 --- a/nestkernel/ntree_impl.h +++ b/nestkernel/ntree_impl.h @@ -83,7 +83,7 @@ Ntree< D, T, max_capacity, max_depth >::iterator::next_leaf_() { // If we are on the last subntree, move up - while ( ntree_ && ( ntree_ != top_ ) && ( ntree_->my_subquad_ == N - 1 ) ) + while ( ntree_ and ( ntree_ != top_ ) and ( ntree_->my_subquad_ == N - 1 ) ) { ntree_ = ntree_->parent_; } @@ -203,7 +203,7 @@ Ntree< D, T, max_capacity, max_depth >::masked_iterator::init_() first_leaf_(); } - if ( ntree_->nodes_.empty() || ( not mask_->inside( ntree_->nodes_[ node_ ].first - anchor_ ) ) ) + if ( ntree_->nodes_.empty() or ( not mask_->inside( ntree_->nodes_[ node_ ].first - anchor_ ) ) ) { ++( *this ); } @@ -250,7 +250,7 @@ Ntree< D, T, max_capacity, max_depth >::masked_iterator::next_leaf_() // state: all in // If we are on the last subtree, move up - while ( ntree_ && ( ntree_ != allin_top_ ) && ( ntree_->my_subquad_ == N - 1 ) ) + while ( ntree_ and ( ntree_ != allin_top_ ) and ( ntree_->my_subquad_ == N - 1 ) ) { ntree_ = ntree_->parent_; } @@ -283,7 +283,7 @@ Ntree< D, T, max_capacity, max_depth >::masked_iterator::next_leaf_() { // If we are on the last subtree, move up - while ( ntree_ && ( ntree_ != top_ ) && ( ntree_->my_subquad_ == N - 1 ) ) + while ( ntree_ and ( ntree_ != top_ ) and ( ntree_->my_subquad_ == N - 1 ) ) { ntree_ = ntree_->parent_; } @@ -357,7 +357,7 @@ Ntree< D, T, max_capacity, max_depth >::masked_iterator::operator++() if ( allin_top_ == 0 ) { while ( - ( node_ < ntree_->nodes_.size() ) && ( not anchored_position_inside_mask( ntree_->nodes_[ node_ ].first ) ) ) + ( node_ < ntree_->nodes_.size() ) and ( not anchored_position_inside_mask( ntree_->nodes_[ node_ ].first ) ) ) { ++node_; } @@ -376,7 +376,7 @@ Ntree< D, T, max_capacity, max_depth >::masked_iterator::operator++() if ( allin_top_ == 0 ) { while ( - ( node_ < ntree_->nodes_.size() ) && ( not anchored_position_inside_mask( ntree_->nodes_[ node_ ].first ) ) ) + ( node_ < ntree_->nodes_.size() ) and ( not anchored_position_inside_mask( ntree_->nodes_[ node_ ].first ) ) ) { ++node_; } @@ -478,7 +478,7 @@ Ntree< D, T, max_capacity, max_depth >::insert( Position< D > pos, const T& node } } - if ( leaf_ && ( nodes_.size() >= max_capacity ) && ( my_depth_ < max_depth ) ) + if ( leaf_ and ( nodes_.size() >= max_capacity ) and ( my_depth_ < max_depth ) ) { split_(); } diff --git a/nestkernel/recording_backend_ascii.cpp b/nestkernel/recording_backend_ascii.cpp index 744b10f546..9fafd34082 100644 --- a/nestkernel/recording_backend_ascii.cpp +++ b/nestkernel/recording_backend_ascii.cpp @@ -251,7 +251,7 @@ nest::RecordingBackendASCII::DeviceData::open_file() std::string filename = compute_filename_(); std::ifstream test( filename.c_str() ); - if ( test.good() && not kernel().io_manager.overwrite_files() ) + if ( test.good() and not kernel().io_manager.overwrite_files() ) { std::string msg = String::compose( "The file '%1' already exists and overwriting files is disabled. To overwrite files, set " diff --git a/nestkernel/recording_backend_sionlib.cpp b/nestkernel/recording_backend_sionlib.cpp index 106905c028..fe5f42b6aa 100644 --- a/nestkernel/recording_backend_sionlib.cpp +++ b/nestkernel/recording_backend_sionlib.cpp @@ -276,7 +276,7 @@ nest::RecordingBackendSIONlib::close_files_() const thread t = kernel().vp_manager.get_thread_id(); const thread task = kernel().vp_manager.thread_to_vp( t ); - assert( ( files_.find( task ) != files_.end() ) && "initialize() was not called before calling cleanup()" ); + assert( ( files_.find( task ) != files_.end() ) and "initialize() was not called before calling cleanup()" ); FileEntry& file = files_[ task ]; SIONBuffer& buffer = file.buffer; diff --git a/nestkernel/recording_device.cpp b/nestkernel/recording_device.cpp index 0eb7d294ea..205fde2e6b 100644 --- a/nestkernel/recording_device.cpp +++ b/nestkernel/recording_device.cpp @@ -205,7 +205,7 @@ nest::RecordingDevice::is_active( Time const& T ) const { const long stamp = T.get_steps(); - return get_t_min_() < stamp && stamp <= get_t_max_(); + return get_t_min_() < stamp and stamp <= get_t_max_(); } void diff --git a/nestkernel/slice_ring_buffer.h b/nestkernel/slice_ring_buffer.h index 0cdfe04a1b..7380a96320 100644 --- a/nestkernel/slice_ring_buffer.h +++ b/nestkernel/slice_ring_buffer.h @@ -181,7 +181,7 @@ SliceRingBuffer::get_next_spike( const long req_stamp, bool& end_of_refract ) { end_of_refract = false; - if ( deliver_->empty() || refract_ <= deliver_->back() ) + if ( deliver_->empty() or refract_ <= deliver_->back() ) { if ( refract_.stamp_ == req_stamp ) { // if relies on stamp_==long::max() if not refractory diff --git a/nestkernel/spatial.cpp b/nestkernel/spatial.cpp index 20edc85161..87455f82c4 100644 --- a/nestkernel/spatial.cpp +++ b/nestkernel/spatial.cpp @@ -446,7 +446,7 @@ dump_layer_connections( const Token& syn_model, DictionaryDatum get_layer_status( NodeCollectionPTR ) { - assert( false && "not implemented" ); + assert( false and "not implemented" ); return DictionaryDatum(); } diff --git a/nestkernel/universal_data_logger.h b/nestkernel/universal_data_logger.h index 3999909eac..6480fa8981 100644 --- a/nestkernel/universal_data_logger.h +++ b/nestkernel/universal_data_logger.h @@ -502,7 +502,7 @@ nest::DynamicUniversalDataLogger< HostNode >::connect_logging_device( const Data const index mm_node_id = req.get_sender().get_node_id(); const size_t n_loggers = data_loggers_.size(); size_t j = 0; - while ( j < n_loggers && data_loggers_[ j ].get_mm_node_id() != mm_node_id ) + while ( j < n_loggers and data_loggers_[ j ].get_mm_node_id() != mm_node_id ) { ++j; } @@ -552,7 +552,7 @@ nest::DynamicUniversalDataLogger< HostNode >::DataLogger_::DataLogger_( const Da num_vars_ = node_access_.size(); - if ( num_vars_ > 0 && req.get_recording_interval() < Time::step( 1 ) ) + if ( num_vars_ > 0 and req.get_recording_interval() < Time::step( 1 ) ) { throw IllegalConnection( "Recording interval must be >= resolution." ); } diff --git a/nestkernel/universal_data_logger_impl.h b/nestkernel/universal_data_logger_impl.h index ce5559f15a..a26b78cf1e 100644 --- a/nestkernel/universal_data_logger_impl.h +++ b/nestkernel/universal_data_logger_impl.h @@ -143,7 +143,7 @@ template < typename HostNode > void nest::DynamicUniversalDataLogger< HostNode >::DataLogger_::record_data( const HostNode&, long step ) { - if ( num_vars_ < 1 || step < next_rec_step_ ) + if ( num_vars_ < 1 or step < next_rec_step_ ) { return; } diff --git a/nestkernel/urbanczik_archiving_node_impl.h b/nestkernel/urbanczik_archiving_node_impl.h index 99c739d64a..fbdfea687c 100644 --- a/nestkernel/urbanczik_archiving_node_impl.h +++ b/nestkernel/urbanczik_archiving_node_impl.h @@ -78,12 +78,12 @@ nest::UrbanczikArchivingNode< urbanczik_parameters >::get_urbanczik_history( dou // To have a well defined discretization of the integral, we make sure // that we exclude the entry at t1 but include the one at t2 by subtracting // a small number so that runner->t_ is never equal to t1 or t2. - while ( ( runner != urbanczik_history_[ comp - 1 ].end() ) && ( runner->t_ - 1.0e-6 < t1 ) ) + while ( ( runner != urbanczik_history_[ comp - 1 ].end() ) and ( runner->t_ - 1.0e-6 < t1 ) ) { ++runner; } *start = runner; - while ( ( runner != urbanczik_history_[ comp - 1 ].end() ) && ( runner->t_ - 1.0e-6 < t2 ) ) + while ( ( runner != urbanczik_history_[ comp - 1 ].end() ) and ( runner->t_ - 1.0e-6 < t2 ) ) { ( runner->access_counter_ )++; ++runner; diff --git a/nestkernel/vp_manager.h b/nestkernel/vp_manager.h index ac472493fd..d35186c641 100644 --- a/nestkernel/vp_manager.h +++ b/nestkernel/vp_manager.h @@ -64,7 +64,7 @@ class VPManager : public ManagerInterface /** * Gets ID of local thread. - * Returns thread ID if OPENMP is installed + * Returns thread ID if OpenMP is installed * and zero otherwise. */ thread get_thread_id() const; diff --git a/sli/dict.h b/sli/dict.h index e29d221b93..8e665479cd 100644 --- a/sli/dict.h +++ b/sli/dict.h @@ -39,7 +39,7 @@ typedef std::map< Name, Token, std::less< Name > > TokenMap; inline bool operator==( const TokenMap& x, const TokenMap& y ) { - return ( x.size() == y.size() ) && equal( x.begin(), x.end(), y.begin() ); + return ( x.size() == y.size() ) and equal( x.begin(), x.end(), y.begin() ); } /** A class that associates names and tokens. diff --git a/sli/dictutils.cc b/sli/dictutils.cc index b6f0201017..85df9fcdbe 100644 --- a/sli/dictutils.cc +++ b/sli/dictutils.cc @@ -63,12 +63,12 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< double > DoubleVectorDatum* arrd = dynamic_cast< DoubleVectorDatum* >( t.datum() ); assert( arrd ); - if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add + if ( ( *arrd )->empty() and not prop.empty() ) // not data from before, add { ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } - assert( prop.empty() || **arrd == prop ); // not testing for **arrd.empty() + assert( prop.empty() or **arrd == prop ); // not testing for **arrd.empty() // since that implies prop.empty() } @@ -81,12 +81,12 @@ provide_property( DictionaryDatum& d, Name propname, const std::vector< long >& IntVectorDatum* arrd = dynamic_cast< IntVectorDatum* >( t.datum() ); assert( arrd ); - if ( ( *arrd )->empty() && not prop.empty() ) // not data from before, add + if ( ( *arrd )->empty() and not prop.empty() ) // not data from before, add { ( *arrd )->insert( ( *arrd )->end(), prop.begin(), prop.end() ); } - assert( prop.empty() || **arrd == prop ); // not testing for **arrd.empty() + assert( prop.empty() or **arrd == prop ); // not testing for **arrd.empty() // since that implies prop.empty() } diff --git a/sli/fdstream.h b/sli/fdstream.h index b5852fdc8e..826f9d65c2 100644 --- a/sli/fdstream.h +++ b/sli/fdstream.h @@ -156,7 +156,7 @@ class fdbuf : public std::streambuf sync() override { std::streamsize size = pptr() - pbase(); - if ( size > 0 && ::write( m_fd, m_outbuf, size ) != size ) + if ( size > 0 and ::write( m_fd, m_outbuf, size ) != size ) { return -1; } diff --git a/sli/filesystem.cc b/sli/filesystem.cc index 679a88d069..ac611576fd 100644 --- a/sli/filesystem.cc +++ b/sli/filesystem.cc @@ -352,7 +352,7 @@ FilesystemModule::CompareFilesFunction::execute( SLIInterpreter* i ) const std::ifstream as( flA->c_str(), std::ifstream::in | std::ifstream::binary ); std::ifstream bs( flB->c_str(), std::ifstream::in | std::ifstream::binary ); - if ( not( as.good() && bs.good() ) ) + if ( not( as.good() and bs.good() ) ) { as.close(); bs.close(); @@ -360,12 +360,12 @@ FilesystemModule::CompareFilesFunction::execute( SLIInterpreter* i ) const } bool equal = true; - while ( equal && as.good() && bs.good() ) + while ( equal and as.good() and bs.good() ) { const int ac = as.get(); const int bc = bs.get(); - if ( not( as.fail() || bs.fail() ) ) + if ( not( as.fail() or bs.fail() ) ) { equal = ac == bc; } diff --git a/sli/interpret.cc b/sli/interpret.cc index c2a5a7bad4..3a75bcd7da 100644 --- a/sli/interpret.cc +++ b/sli/interpret.cc @@ -882,7 +882,7 @@ SLIInterpreter::message( std::ostream& out, for ( size_t i = 0; i < text_str.size(); ++i ) { - if ( text_str.at( i ) == '\n' && i != text_str.size() - 1 ) + if ( text_str.at( i ) == '\n' and i != text_str.size() - 1 ) { // Print a lineshift followed by an indented whitespace // Manually inserted lineshift at the end of the message @@ -906,8 +906,8 @@ SLIInterpreter::message( std::ostream& out, // Start on a new line if the next word is longer than the // space available (as long as the word is shorter than the // total width of the printout). - if ( i != 0 && text_str.at( i - 1 ) == ' ' - && static_cast< int >( space - i ) > static_cast< int >( width - pos ) ) + if ( i != 0 and text_str.at( i - 1 ) == ' ' + and static_cast< int >( space - i ) > static_cast< int >( width - pos ) ) { out << std::endl << std::string( indent, ' ' ); pos = 0; @@ -915,7 +915,7 @@ SLIInterpreter::message( std::ostream& out, // Only print character if we're not at the end of the // line and the last character is a space. - if ( not( width - pos == 0 && text_str.at( i ) == ' ' ) ) + if ( not( width - pos == 0 and text_str.at( i ) == ' ' ) ) { // Print the actual character. out << text_str.at( i ); @@ -1099,7 +1099,7 @@ SLIInterpreter::debug_commandline( Token& next ) { stack_backtrace( EStack.load() ); } - else if ( arg == "next" || arg == "n" ) + else if ( arg == "next" or arg == "n" ) { std::cerr << "Next token: "; next.pprint( std::cerr ); @@ -1129,13 +1129,13 @@ SLIInterpreter::debug_commandline( Token& next ) catch_errors_ = not catch_errors_; std::cerr << "Catch error mode is now " << ( catch_errors_ ? " On." : "Off." ) << std::endl; } - else if ( arg == "tailrecursion" || arg == "tail" ) + else if ( arg == "tailrecursion" or arg == "tail" ) { opt_tailrecursion_ = not opt_tailrecursion_; std::cerr << "Tail-recursion optimization is now " << ( opt_tailrecursion_ ? " On." : "Off." ) << std::endl; } } - else if ( command == "list" || command == "l" ) + else if ( command == "list" or command == "l" ) { c = 'l'; break; @@ -1151,11 +1151,11 @@ SLIInterpreter::debug_commandline( Token& next ) catch_errors_ = true; std::cerr << "Catch error mode is now " << ( catch_errors_ ? " On." : "Off." ) << std::endl; } - else if ( command == "where" || command == "w" ) + else if ( command == "where" or command == "w" ) { stack_backtrace( EStack.load() ); } - else if ( command == "edit" || command == "break" || command == "e" ) + else if ( command == "edit" or command == "break" or command == "e" ) { debug_mode_off(); std::cerr << "Type 'continue', to exit interactive mode." << std::endl; @@ -1174,15 +1174,15 @@ SLIInterpreter::debug_commandline( Token& next ) { EStack.dump( std::cerr ); } - else if ( command == "help" || command == "?" || command == "h" ) + else if ( command == "help" or command == "?" or command == "h" ) { debug_options(); } - else if ( command == "next" || command == "n" ) + else if ( command == "next" or command == "n" ) { break; } - else if ( command == "continue" || command == "cont" || command == "c" ) + else if ( command == "continue" or command == "cont" or command == "c" ) { max_call_depth_ = call_depth_; // will show lower levels only } @@ -1190,7 +1190,7 @@ SLIInterpreter::debug_commandline( Token& next ) { max_call_depth_ = call_depth_ + 1; // will this level and lower. } - else if ( command == "quit" || command == "q" ) + else if ( command == "quit" or command == "q" ) { debug_mode_ = false; break; @@ -1210,7 +1210,7 @@ SLIInterpreter::startup() static bool is_initialized = false; int exitcode = EXIT_SUCCESS; - if ( not is_initialized && EStack.load() > 0 ) + if ( not is_initialized and EStack.load() > 0 ) { exitcode = execute_(); // run the interpreter is_initialized = true; diff --git a/sli/interpret.h b/sli/interpret.h index 07a134b10c..ed09eb9361 100644 --- a/sli/interpret.h +++ b/sli/interpret.h @@ -435,7 +435,7 @@ class SLIInterpreter bool step_mode() const { - return debug_mode_ && ( call_depth_ < max_call_depth_ ); + return debug_mode_ and ( call_depth_ < max_call_depth_ ); } /** diff --git a/sli/lockptrdatum.h b/sli/lockptrdatum.h index ff43a2d356..3f49ff866c 100644 --- a/sli/lockptrdatum.h +++ b/sli/lockptrdatum.h @@ -123,7 +123,7 @@ bool lockPTRDatum< D, slt >::equals( const Datum* dat ) const { const lockPTRDatum< D, slt >* ddc = dynamic_cast< const lockPTRDatum< D, slt >* >( dat ); - return ddc && lockPTR< D >::operator==( *ddc ); + return ddc and lockPTR< D >::operator==( *ddc ); } template < class D, SLIType* slt > diff --git a/sli/parser.cc b/sli/parser.cc index 0313b69063..797892a281 100644 --- a/sli/parser.cc +++ b/sli/parser.cc @@ -180,7 +180,7 @@ Parser::operator()( Token& t ) } // if(ok) // else std::cerr << " : unable to scan input, Result:" << ok // << '\n'; - } while ( ( result == tokencontinue ) || ( result == scancontinue ) ); + } while ( ( result == tokencontinue ) or ( result == scancontinue ) ); if ( result != tokencompleted ) { diff --git a/sli/processes.cc b/sli/processes.cc index 5bd9aa9637..54926210b1 100644 --- a/sli/processes.cc +++ b/sli/processes.cc @@ -133,7 +133,7 @@ Processes::fd( std::ostream* s ) { return STDOUT_FILENO; } - else if ( ( s == &std::cerr ) || ( s == &std::clog ) ) + else if ( ( s == &std::cerr ) or ( s == &std::clog ) ) { return STDERR_FILENO; } @@ -664,7 +664,7 @@ Processes::AvailableFunction::execute( SLIInterpreter* i ) const // fcntl(fd,F_SETFL,flags); //reset to old value // // ------------------------------ - // if ( (peekchar==-1) && (errno!=EAGAIN) && (errno!=ESPIPE) ) + // if ( (peekchar==-1) and (errno!=EAGAIN) and (errno!=ESPIPE) ) // {// some unexpected error occured! // i->raiseerror(systemerror(i)); // } diff --git a/sli/scanner.cc b/sli/scanner.cc index d819e68a30..32599eaef6 100644 --- a/sli/scanner.cc +++ b/sli/scanner.cc @@ -548,7 +548,7 @@ Scanner::operator()( Token& t ) do { - if ( not in->eof() && not in->good() ) + if ( not in->eof() and not in->good() ) { std::cout << "I/O Error in scanner input stream." << std::endl; state = error; @@ -565,7 +565,7 @@ Scanner::operator()( Token& t ) ++line; } - if ( c == '\0' || in->bad() ) + if ( c == '\0' or in->bad() ) { c = endof; } @@ -604,7 +604,7 @@ Scanner::operator()( Token& t ) { IntegerDatum id( lng ); t = id; - if ( c != endoln && c != endof ) + if ( c != endoln and c != endof ) { in->unget(); --col; @@ -654,7 +654,7 @@ Scanner::operator()( Token& t ) ds.clear(); t.move( doubletoken ); - if ( c != endoln && c != endof ) + if ( c != endoln and c != endof ) { in->unget(); --col; @@ -705,7 +705,7 @@ Scanner::operator()( Token& t ) state = alphast; break; case sgalphast: - assert( sgc == '+' || sgc == '-' ); + assert( sgc == '+' or sgc == '-' ); s.append( 1, sgc ); state = alphast; /* no break */ @@ -739,7 +739,7 @@ Scanner::operator()( Token& t ) /* no break */ case aheadalphst: { - if ( c != endoln && c != endof ) + if ( c != endoln and c != endof ) { in->unget(); --col; @@ -752,7 +752,7 @@ Scanner::operator()( Token& t ) case aheadlitst: { - if ( c != endoln && c != endof ) + if ( c != endoln and c != endof ) { in->unget(); --col; @@ -804,7 +804,7 @@ Scanner::operator()( Token& t ) default: break; } - } while ( ( state != error ) && ( state != end ) ); + } while ( ( state != error ) and ( state != end ) ); return ( state == end ); } diff --git a/sli/sharedptrdatum.h b/sli/sharedptrdatum.h index 4b9fa0f8f1..7a8bf7c259 100644 --- a/sli/sharedptrdatum.h +++ b/sli/sharedptrdatum.h @@ -91,7 +91,7 @@ class sharedPtrDatum : public std::shared_ptr< D >, public TypedDatum< slt > equals( const Datum* other ) const { const sharedPtrDatum< D, slt >* other_dc = dynamic_cast< const sharedPtrDatum< D, slt >* >( other ); - return other_dc && *this == *other_dc; + return other_dc and *this == *other_dc; } }; diff --git a/sli/sli_io.cc b/sli/sli_io.cc index 3b8c31e389..1f9f5f6c22 100644 --- a/sli/sli_io.cc +++ b/sli/sli_io.cc @@ -971,7 +971,7 @@ IOSScientificFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -999,7 +999,7 @@ IOSDefaultFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1027,7 +1027,7 @@ IOSShowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1054,7 +1054,7 @@ IOSNoshowpointFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1082,7 +1082,7 @@ IOSOctFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1109,7 +1109,7 @@ IOSHexFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1136,7 +1136,7 @@ IOSDecFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1163,7 +1163,7 @@ IOSShowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1190,7 +1190,7 @@ IOSNoshowbaseFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1217,7 +1217,7 @@ IOSLeftFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1246,7 +1246,7 @@ IOSRightFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1275,7 +1275,7 @@ IOSInternalFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.pick( 0 ).datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1316,7 +1316,7 @@ GetcFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1356,7 +1356,7 @@ GetsFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1405,14 +1405,14 @@ GetlineFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); throw TypeMismatch( d.gettypename().toString(), t.datum()->gettypename().toString() ); } - if ( ( *istreamdatum )->good() && not( *istreamdatum )->eof() ) + if ( ( *istreamdatum )->good() and not( *istreamdatum )->eof() ) { string s; getline( **istreamdatum, s ); @@ -1459,7 +1459,7 @@ IGoodFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1500,7 +1500,7 @@ IClearFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1534,7 +1534,7 @@ OClearFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1569,7 +1569,7 @@ IFailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1611,7 +1611,7 @@ OGoodFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1652,7 +1652,7 @@ IEofFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1694,7 +1694,7 @@ OEofFunction::execute( SLIInterpreter* i ) const OstreamDatum* ostreamdatum = dynamic_cast< OstreamDatum* >( i->OStack.top().datum() ); - if ( not ostreamdatum || not ostreamdatum->valid() ) + if ( not ostreamdatum or not ostreamdatum->valid() ) { OstreamDatum const d; Token t = i->OStack.top(); @@ -1749,7 +1749,7 @@ In_AvailFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); @@ -1866,7 +1866,7 @@ ReadWordFunction::execute( SLIInterpreter* i ) const IstreamDatum* istreamdatum = dynamic_cast< IstreamDatum* >( i->OStack.top().datum() ); - if ( not istreamdatum || not istreamdatum->valid() ) + if ( not istreamdatum or not istreamdatum->valid() ) { IstreamDatum const d; Token t = i->OStack.top(); diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 976325d160..169ad674d4 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -106,7 +106,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) && ( n2d ) ) + if ( ( n1d ) and ( n2d ) ) { long n = 1 + n2d->get() - n1d->get(); @@ -130,7 +130,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) && ( n2d ) ) + if ( ( n1d ) and ( n2d ) ) { long n = 1 + static_cast< long >( n2d->get() - n1d->get() ); @@ -161,7 +161,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) && ( n2d ) && ( n3d ) ) + if ( ( n1d ) and ( n2d ) and ( n3d ) ) { long di = n3d->get(); long start = n1d->get(); @@ -192,7 +192,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) && ( n2d ) && ( n3d ) ) + if ( ( n1d ) and ( n2d ) and ( n3d ) ) { double di = n3d->get(); double start = n1d->get(); @@ -286,7 +286,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) && ( n2d ) ) + if ( ( n1d ) and ( n2d ) ) { const long start = n1d->get(); const long stop = n2d->get(); @@ -310,7 +310,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) && ( n2d ) ) + if ( ( n1d ) and ( n2d ) ) { double start = n1d->get(); double stop = n2d->get(); @@ -338,7 +338,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) && ( n2d ) && ( n3d ) ) + if ( ( n1d ) and ( n2d ) and ( n3d ) ) { long di = n3d->get(); long start = n1d->get(); @@ -372,7 +372,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) && ( n2d ) && ( n3d ) ) + if ( ( n1d ) and ( n2d ) and ( n3d ) ) { double di = n3d->get(); double start = n1d->get(); @@ -907,7 +907,7 @@ SLIArrayModule::ArraycreateFunction::execute( SLIInterpreter* i ) const const Token mark_token( new LiteralDatum( i->mark_name ) ); bool found = false; - while ( ( n < depth ) && not found ) + while ( ( n < depth ) and not found ) { found = ( i->OStack.pick( n ) == mark_token ); ++n; @@ -2739,7 +2739,7 @@ SLIArrayModule::GaborFunction::execute( SLIInterpreter* i ) const i->raiseerror( "RangeCheck" ); return; } - if ( ( ncol < 2 ) || ( nrow < 2 ) ) + if ( ( ncol < 2 ) or ( nrow < 2 ) ) { i->message( SLIInterpreter::M_ERROR, "Gabor_", "Matrix must have at least two rows and two columns." ); i->raiseerror( "RangeCheck" ); @@ -2847,7 +2847,7 @@ SLIArrayModule::Gauss2dFunction::execute( SLIInterpreter* i ) const i->raiseerror( "RangeCheck" ); return; } - if ( ( ncol < 2 ) || ( nrow < 2 ) ) + if ( ( ncol < 2 ) or ( nrow < 2 ) ) { i->message( SLIInterpreter::M_ERROR, "gauss2d_", "Matrix must have at least two rows and two columns." ); i->raiseerror( "RangeCheck" ); @@ -4135,7 +4135,7 @@ eq_execute( SLIInterpreter* i ) op1->unlock(); const std::vector< D >* d2 = op2->get(); op2->unlock(); - bool eq = ( d1 == d2 || *d1 == *d2 ); + bool eq = ( d1 == d2 or *d1 == *d2 ); i->OStack.pop( 2 ); i->OStack.push_by_pointer( new BoolDatum( eq ) ); diff --git a/sli/slibuiltins.cc b/sli/slibuiltins.cc index 77307a1f94..dddc0b2ecd 100644 --- a/sli/slibuiltins.cc +++ b/sli/slibuiltins.cc @@ -233,8 +233,8 @@ IforFunction::execute( SLIInterpreter* i ) const IntegerDatum* inc = static_cast< IntegerDatum* >( i->EStack.pick( 5 ).datum() ); - if ( ( ( inc->get() > 0 ) && ( count->get() <= lim->get() ) ) - || ( ( inc->get() < 0 ) && ( count->get() >= lim->get() ) ) ) + if ( ( ( inc->get() > 0 ) and ( count->get() <= lim->get() ) ) + or ( ( inc->get() < 0 ) and ( count->get() >= lim->get() ) ) ) { pos = 0; // reset procedure interator diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index a09d58f8ad..296cd967f9 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -182,7 +182,7 @@ ExitFunction::execute( SLIInterpreter* i ) const size_t n = 1; size_t load = i->EStack.load(); - while ( ( load > n ) && not( i->EStack.pick( n++ ) == mark ) ) + while ( ( load > n ) and not( i->EStack.pick( n++ ) == mark ) ) { // do nothing } @@ -443,19 +443,19 @@ StopFunction::execute( SLIInterpreter* i ) const bool found = false; size_t n = 1; - while ( ( load > n ) && not( found ) ) + while ( ( load > n ) and not( found ) ) { found = i->EStack.pick( n++ ).contains( istopped ); } - if ( i->catch_errors() && not found ) + if ( i->catch_errors() and not found ) { i->debug_mode_on(); } - if ( i->get_debug_mode() || i->show_backtrace() ) + if ( i->get_debug_mode() or i->show_backtrace() ) { - if ( i->show_backtrace() || not found ) + if ( i->show_backtrace() or not found ) { i->stack_backtrace( load - 1 ); } @@ -507,19 +507,19 @@ CloseinputFunction::execute( SLIInterpreter* i ) const bool found = false; size_t n = 1; - while ( ( load > n ) && not( found ) ) + while ( ( load > n ) and not( found ) ) { found = i->EStack.pick( n++ )->isoftype( SLIInterpreter::XIstreamtype ); } - if ( i->catch_errors() || not found ) + if ( i->catch_errors() or not found ) { i->debug_mode_on(); } - if ( i->get_debug_mode() || i->show_backtrace() ) + if ( i->get_debug_mode() or i->show_backtrace() ) { - if ( i->show_backtrace() || not found ) + if ( i->show_backtrace() or not found ) { i->stack_backtrace( n ); } @@ -601,7 +601,7 @@ CurrentnameFunction::execute( SLIInterpreter* i ) const bool found = false; - while ( ( load > n ) && not found ) + while ( ( load > n ) and not found ) { found = i->EStack.pick( n++ ) == i->baselookup( i->ilookup_name ); } @@ -1170,7 +1170,7 @@ RaiseerrorFunction::execute( SLIInterpreter* i ) const Name* errorname = dynamic_cast< Name* >( err.datum() ); Name* cmdname = dynamic_cast< Name* >( cmd.datum() ); - if ( ( not errorname ) || ( not cmdname ) ) + if ( ( not errorname ) or ( not cmdname ) ) { i->message( SLIInterpreter::M_ERROR, "raiseerror", "Usage: /command /errorname raiserror" ); i->raiseerror( "ArgumentType" ); @@ -1389,7 +1389,7 @@ SwitchFunction::execute( SLIInterpreter* i ) const bool found = ( i->OStack.pick( pos ) == mark_token ); - while ( ( pos < depth ) && not found ) + while ( ( pos < depth ) and not found ) { i->EStack.push_move( i->OStack.pick( pos ) ); found = ( i->OStack.pick( ++pos ) == mark_token ); @@ -1429,8 +1429,8 @@ SwitchdefaultFunction::execute( SLIInterpreter* i ) const throw TypeMismatch( "At least 1 argument.", "Nothing." ); } - if ( depth > 1 && i->OStack.pick( 1 ) != mark_token // default action - && i->OStack.pick( 0 ) != mark_token ) // is not the only one + if ( depth > 1 and i->OStack.pick( 1 ) != mark_token // default action + and i->OStack.pick( 0 ) != mark_token ) // is not the only one { i->OStack.pop(); // thus pop it! } @@ -1438,7 +1438,7 @@ SwitchdefaultFunction::execute( SLIInterpreter* i ) const bool found = ( i->OStack.pick( pos ) == mark_token ); - while ( ( pos < depth ) && not found ) + while ( ( pos < depth ) and not found ) { i->EStack.push_move( i->OStack.pick( pos ) ); found = ( i->OStack.pick( ++pos ) == mark_token ); @@ -1495,7 +1495,7 @@ CounttomarkFunction::execute( SLIInterpreter* i ) const bool found = false; - while ( ( pos < depth ) && not found ) + while ( ( pos < depth ) and not found ) { found = ( i->OStack.pick( pos ) == mark_token ); ++pos; diff --git a/sli/slidata.cc b/sli/slidata.cc index 5650187278..a359403f3d 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -67,7 +67,7 @@ Get_aFunction::execute( SLIInterpreter* i ) const assert( obj ); - if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) + if ( ( idx->get() >= 0 ) and ( ( size_t ) idx->get() < obj->size() ) ) { i->EStack.pop(); Token objT( obj->get( idx->get() ) ); @@ -120,7 +120,7 @@ Get_a_aFunction::execute( SLIInterpreter* i ) const continue; } - if ( not( ( id->get() >= 0 ) && ( ( size_t ) id->get() < obj->size() ) ) ) + if ( not( ( id->get() >= 0 ) and ( ( size_t ) id->get() < obj->size() ) ) ) { std::ostringstream sout; sout << "At position " << ( size_t ) ( t - idx->begin() ) << "." << std::ends; @@ -159,7 +159,7 @@ Get_pFunction::execute( SLIInterpreter* i ) const assert( obj ); - if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) + if ( ( idx->get() >= 0 ) and ( ( size_t ) idx->get() < obj->size() ) ) { i->EStack.pop(); Token objT( obj->get( idx->get() ) ); @@ -183,7 +183,7 @@ Get_lpFunction::execute( SLIInterpreter* i ) const LitprocedureDatum* obj = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 1 ).datum() ); assert( obj ); - if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) + if ( ( idx->get() >= 0 ) and ( ( size_t ) idx->get() < obj->size() ) ) { i->EStack.pop(); Token objT( obj->get( idx->get() ) ); @@ -251,7 +251,7 @@ Append_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd && id ); + assert( sd and id ); ( *sd ) += static_cast< char >( id->get() ); @@ -307,7 +307,7 @@ Join_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 && a2 ); + assert( a1 and a2 ); a1->append_move( *a2 ); @@ -325,7 +325,7 @@ Join_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* a1 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 1 ).datum() ); ProcedureDatum* a2 = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 && a2 ); + assert( a1 and a2 ); a1->append_move( *a2 ); @@ -355,9 +355,9 @@ Insert_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && s2 ); + assert( s1 and id and s2 ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { i->EStack.pop(); s1->insert( id->get(), *s2 ); @@ -391,9 +391,9 @@ InsertElement_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && c ); + assert( s1 and id and c ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { i->EStack.pop(); s1->insert( id->get(), 1, static_cast< char >( c->get() ) ); @@ -430,7 +430,7 @@ Prepend_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* c = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && c ); + assert( s1 and c ); s1->insert( ( size_t ) 0, 1, static_cast< char >( c->get() ) ); @@ -447,9 +447,9 @@ Insert_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* a2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( a1 && id && a2 ); + assert( a1 and id and a2 ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < a1->size() ) ) { i->EStack.pop(); a1->insert_move( id->get(), *a2 ); // ArrayDatum is a TokenArray. @@ -470,9 +470,9 @@ InsertElement_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* a1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( a1 && id ); + assert( a1 and id ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < a1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < a1->size() ) ) { i->EStack.pop(); a1->insert_move( id->get(), i->OStack.top() ); @@ -544,9 +544,9 @@ Replace_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && n && s2 ); + assert( s1 and id and n and s2 ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { if ( n->get() >= 0 ) { @@ -576,9 +576,9 @@ Replace_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && n && s2 ); + assert( s1 and id and n and s2 ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { if ( n->get() >= 0 ) { @@ -621,9 +621,9 @@ Erase_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && n ); + assert( s1 and id and n ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { if ( n->get() >= 0 ) { @@ -652,7 +652,7 @@ Erase_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && n ); + assert( s1 and id && n ); if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) { diff --git a/sli/slidict.cc b/sli/slidict.cc index 5d4a2804a8..bb417a1bf6 100644 --- a/sli/slidict.cc +++ b/sli/slidict.cc @@ -645,7 +645,7 @@ DictconstructFunction::execute( SLIInterpreter* i ) const static Token mark = i->baselookup( i->mark_name ); size_t n = 0; //!< pick(1) is the first literal, then we count in steps of 2 - while ( ( n < load ) && not( i->OStack.pick( n ) == mark ) ) + while ( ( n < load ) and not( i->OStack.pick( n ) == mark ) ) { Token& val = ( i->OStack.pick( n ) ); key = dynamic_cast< LiteralDatum* >( i->OStack.pick( n + 1 ).datum() ); diff --git a/sli/sliexceptions.cc b/sli/sliexceptions.cc index d5bc0db2e3..b1dd5706e7 100644 --- a/sli/sliexceptions.cc +++ b/sli/sliexceptions.cc @@ -54,7 +54,7 @@ DivisionByZero::message() const std::string TypeMismatch::message() const { - if ( not provided_.empty() && not expected_.empty() ) + if ( not provided_.empty() and not expected_.empty() ) { return "Expected datatype: " + expected_ + "\nProvided datatype: " + provided_; } diff --git a/sli/sligraphics.cc b/sli/sligraphics.cc index b426c11bde..cecdae6cca 100644 --- a/sli/sligraphics.cc +++ b/sli/sligraphics.cc @@ -193,13 +193,13 @@ SLIgraphics::ReadPGMFunction::readImage( std::istream* in, if ( std::string( magic ) == std::string( "P2" ) ) // ASCII PGM { int tmp; - while ( ( *in >> tmp ) && not( in->eof() ) ) + while ( ( *in >> tmp ) and not( in->eof() ) ) { image.push_back( ( long ) tmp ); } } else if ( std::string( magic ) == std::string( "P5" ) - || std::string( magic ) == std::string( "P6" ) ) // Raw PGM (resp. PPM) + or std::string( magic ) == std::string( "P6" ) ) // Raw PGM (resp. PPM) { if ( maxval > 255 ) { @@ -210,7 +210,7 @@ SLIgraphics::ReadPGMFunction::readImage( std::istream* in, in->read( &tmp, 1 ); // throw away LF after maxval // TODO: Protect this from reading too much data like trailing // newlines: use for instead of while - while ( in->read( &tmp, 1 ) && not( in->eof() ) ) + while ( in->read( &tmp, 1 ) and not( in->eof() ) ) { tmp2 = ( unsigned char ) tmp; image.push_back( ( long ) tmp2 ); diff --git a/sli/slimath.cc b/sli/slimath.cc index df46615608..e4a7bc57b3 100644 --- a/sli/slimath.cc +++ b/sli/slimath.cc @@ -603,7 +603,7 @@ Pow_diFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); // can raise anything to an integer power, except zero to neg power - if ( not( op1->get() == 0.0 && op2->get() < 0 ) ) + if ( not( op1->get() == 0.0 and op2->get() < 0 ) ) { // cast explicitly to double to avoid overloading ambiguity *op1 = std::pow( op1->get(), static_cast< double >( op2->get() ) ); @@ -1119,7 +1119,7 @@ OrFunction::execute( SLIInterpreter* i ) const BoolDatum* op1 = static_cast< BoolDatum* >( i->OStack.pick( 1 ).datum() ); BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); op1->get() = ( op1->get() or op2->get() ); @@ -1149,7 +1149,7 @@ XorFunction::execute( SLIInterpreter* i ) const BoolDatum* op1 = static_cast< BoolDatum* >( i->OStack.pick( 1 ).datum() ); BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); - op1->get() = ( ( *op1 || *op2 ) && not( *op1 && *op2 ) ); + op1->get() = ( ( *op1 or *op2 ) and not( *op1 and *op2 ) ); i->OStack.pop(); } @@ -1177,7 +1177,7 @@ AndFunction::execute( SLIInterpreter* i ) const BoolDatum* op1 = static_cast< BoolDatum* >( i->OStack.pick( 1 ).datum() ); BoolDatum* op2 = static_cast< BoolDatum* >( i->OStack.pick( 0 ).datum() ); - op1->get() = ( *op1 && *op2 ); + op1->get() = ( *op1 and *op2 ); i->OStack.pop(); } @@ -1261,7 +1261,7 @@ Gt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() > op2->get(); @@ -1278,7 +1278,7 @@ Gt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() > op2->get(); @@ -1296,7 +1296,7 @@ Gt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = *op1 > *op2; @@ -1323,7 +1323,7 @@ Lt_idFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() < op2->get(); @@ -1340,7 +1340,7 @@ Lt_diFunction::execute( SLIInterpreter* i ) const IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() < op2->get(); @@ -1358,7 +1358,7 @@ Lt_iiFunction::execute( SLIInterpreter* i ) const IntegerDatum* op1 = static_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* op2 = static_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() < op2->get(); @@ -1375,7 +1375,7 @@ Lt_ddFunction::execute( SLIInterpreter* i ) const DoubleDatum* op1 = static_cast< DoubleDatum* >( i->OStack.pick( 1 ).datum() ); DoubleDatum* op2 = static_cast< DoubleDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = op1->get() < op2->get(); @@ -1393,7 +1393,7 @@ Lt_ssFunction::execute( SLIInterpreter* i ) const StringDatum* op1 = static_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* op2 = static_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( op1 && op2 ); + assert( op1 and op2 ); bool result = *op1 < *op2; diff --git a/sli/slistartup.cc b/sli/slistartup.cc index cb92f0d9a6..542445f266 100644 --- a/sli/slistartup.cc +++ b/sli/slistartup.cc @@ -208,7 +208,7 @@ SLIStartup::SLIStartup( int argc, char** argv ) StringDatum* sd = new StringDatum( argv[ i ] ); args_array.push_back( Token( sd ) ); - if ( *sd == "-d" || *sd == "--debug" ) + if ( *sd == "-d" or *sd == "--debug" ) { debug_ = true; verbosity_ = SLIInterpreter::M_ALL; // make the interpreter verbose. diff --git a/sli/specialfunctionsmodule.cc b/sli/specialfunctionsmodule.cc index 6167ef2d7c..b3a850629b 100644 --- a/sli/specialfunctionsmodule.cc +++ b/sli/specialfunctionsmodule.cc @@ -341,7 +341,7 @@ SpecialFunctionsModule::GaussDiskConvFunction::execute( SLIInterpreter* i ) cons { /* Gaussian in disk */ result = 1.0; } - else if ( y > 1 && r0 > R + sqrt( -log( GSL_DBL_EPSILON / y ) ) ) + else if ( y > 1 and r0 > R + sqrt( -log( GSL_DBL_EPSILON / y ) ) ) { /* tail */ result = 0.25 * R / r0 * ( std::exp( -( r0 - R ) * ( r0 - R ) ) - std::exp( -( r0 + R ) * ( r0 + R ) ) ); } diff --git a/sli/tarrayobj.cc b/sli/tarrayobj.cc index 919ac172bb..61ebd7eeae 100644 --- a/sli/tarrayobj.cc +++ b/sli/tarrayobj.cc @@ -133,7 +133,7 @@ TokenArrayObj::resize( size_t s, size_t alloc, const Token& t ) { alloc_block_size = ( alloc == 0 ) ? alloc_block_size : alloc; - if ( ( s != size() && ( s != 0 ) ) || ( size() == 0 && alloc_block_size != 0 ) ) + if ( ( s != size() and ( s != 0 ) ) or ( size() == 0 and alloc_block_size != 0 ) ) { allocate( s, s + alloc_block_size, alloc_block_size, t ); } @@ -240,7 +240,7 @@ TokenArrayObj::rotate( Token* first, Token* middle, Token* last ) { // This algorithm is taken from the HP STL implementation. - if ( ( first < middle ) && ( middle < last ) ) + if ( ( first < middle ) and ( middle < last ) ) { for ( Token* i = middle;; ) { @@ -630,7 +630,7 @@ TokenArrayObj::operator==( const TokenArrayObj& a ) const // experimentally replaced by line below 090120, Diesmann // because [] cvx has non NULL p // - // if( p == NULL || a.p == NULL || size() != a.size()) + // if( p == NULL or a.p == NULL or size() != a.size()) // return false; if ( size() != a.size() ) diff --git a/sli/tokenarray.h b/sli/tokenarray.h index 0e4dc7a04c..5e1d57d8ee 100644 --- a/sli/tokenarray.h +++ b/sli/tokenarray.h @@ -398,7 +398,7 @@ class TokenArray void erase( size_t i, size_t n ) { - if ( i < size() && n > 0 ) + if ( i < size() and n > 0 ) { clone(); data->erase( i, n ); @@ -409,7 +409,7 @@ class TokenArray void reduce( size_t i, size_t n ) { - if ( i > 0 || n < size() ) + if ( i > 0 or n < size() ) { clone(); data->reduce( i, n ); @@ -474,7 +474,7 @@ TokenArray::reverse() inline void TokenArray::rotate( long n = 1 ) { - if ( size() == 0 || n == 0 ) + if ( size() == 0 or n == 0 ) { return; } diff --git a/sli/tokenstack.h b/sli/tokenstack.h index 7ffb99ba35..2a5d26a888 100644 --- a/sli/tokenstack.h +++ b/sli/tokenstack.h @@ -160,7 +160,7 @@ class TokenStack : private TokenArrayObj void roll( size_t n, long k ) { - if ( n < 2 || k == 0 ) + if ( n < 2 and k == 0 ) { return; // nothing to do } diff --git a/sli/typechk.h b/sli/typechk.h index dd86e3ab38..461fca61ed 100644 --- a/sli/typechk.h +++ b/sli/typechk.h @@ -199,7 +199,7 @@ inline TypeTrie::~TypeTrie() inline bool TypeTrie::equals( const Name& t1, const Name& t2 ) const { - return ( t1 == t2 || t2 == sli::any || t1 == sli::any ); + return ( t1 == t2 or t2 == sli::any or t1 == sli::any ); } inline const Token& From bb84f1fa9dfa8784b819745aa99246afd66a0cf9 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 11 Oct 2022 00:38:17 +0200 Subject: [PATCH 115/150] Removed redundant parentheses and found some more occurrences of || --- libnestutil/lockptr.h | 2 +- models/aeif_cond_alpha_multisynapse.cpp | 10 ++++---- models/aeif_cond_beta_multisynapse.cpp | 16 ++++++------ models/aeif_cond_exp.cpp | 2 +- models/aeif_psc_alpha.cpp | 6 ++--- models/aeif_psc_delta.cpp | 2 +- models/aeif_psc_delta_clopath.cpp | 4 +-- models/aeif_psc_exp.cpp | 6 ++--- models/amat2_psc_exp.cpp | 6 ++--- models/cm_tree.cpp | 4 +-- models/gif_cond_exp_multisynapse.cpp | 6 ++--- models/glif_cond.cpp | 4 +-- models/hh_cond_beta_gap_traub.cpp | 6 ++--- models/hh_cond_exp_traub.cpp | 4 +-- models/iaf_chs_2007.cpp | 2 +- models/iaf_cond_alpha_mc.cpp | 2 +- models/iaf_cond_beta.cpp | 2 +- models/iaf_cond_exp.cpp | 2 +- models/iaf_cond_exp_sfa_rr.cpp | 2 +- models/iaf_psc_alpha.cpp | 2 +- models/iaf_psc_alpha_canon.cpp | 2 +- models/iaf_psc_alpha_multisynapse.cpp | 2 +- models/iaf_psc_alpha_ps.cpp | 2 +- models/iaf_psc_exp.cpp | 2 +- models/iaf_psc_exp_htum.cpp | 2 +- models/iaf_psc_exp_multisynapse.cpp | 2 +- models/iaf_psc_exp_ps.cpp | 2 +- models/multimeter.cpp | 4 +-- models/music_cont_out_proxy.cpp | 4 +-- models/poisson_generator_ps.cpp | 2 +- models/pp_cond_exp_mc_urbanczik.cpp | 2 +- models/ppd_sup_generator.cpp | 6 ++--- models/spike_generator.cpp | 16 ++++++------ models/tsodyks_synapse_hom.cpp | 2 +- nestkernel/connection_creator_impl.h | 34 ++++++++++++------------- nestkernel/exceptions.h | 2 +- sli/sliarray.cc | 16 ++++++------ sli/slicontrol.cc | 2 +- sli/token.h | 2 +- 39 files changed, 98 insertions(+), 98 deletions(-) diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index c1b7a26954..16156afcae 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -114,7 +114,7 @@ class lockPTR ~PointerObject() { assert( not locked ); - if ( ( pointee != NULL ) and deletable and ( not locked ) ) + if ( ( pointee != NULL ) and deletable and locked ) { delete pointee; } diff --git a/models/aeif_cond_alpha_multisynapse.cpp b/models/aeif_cond_alpha_multisynapse.cpp index e15418b494..837980fad5 100644 --- a/models/aeif_cond_alpha_multisynapse.cpp +++ b/models/aeif_cond_alpha_multisynapse.cpp @@ -218,10 +218,10 @@ aeif_cond_alpha_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* const size_t old_n_receptors = n_receptors(); bool Erev_flag = updateValue< std::vector< double > >( d, names::E_rev, E_rev ); bool tau_flag = updateValue< std::vector< double > >( d, names::tau_syn, tau_syn ); - if ( Erev_flag || tau_flag ) + if ( Erev_flag or tau_flag ) { // receptor arrays have been modified - if ( ( E_rev.size() != old_n_receptors || tau_syn.size() != old_n_receptors ) - and ( not Erev_flag || not tau_flag ) ) + if ( ( E_rev.size() != old_n_receptors or tau_syn.size() != old_n_receptors ) + and ( not Erev_flag or not tau_flag ) ) { throw BadProperty( "If the number of receptor ports is changed, both arrays " @@ -524,7 +524,7 @@ aeif_cond_alpha_multisynapse::update( Time const& origin, const long from, const } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } @@ -574,7 +574,7 @@ aeif_cond_alpha_multisynapse::update( Time const& origin, const long from, const port aeif_cond_alpha_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/aeif_cond_beta_multisynapse.cpp b/models/aeif_cond_beta_multisynapse.cpp index b1d4fdf59c..627e396767 100644 --- a/models/aeif_cond_beta_multisynapse.cpp +++ b/models/aeif_cond_beta_multisynapse.cpp @@ -221,17 +221,17 @@ aeif_cond_beta_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* n bool Erev_flag = updateValue< std::vector< double > >( d, names::E_rev, E_rev ); bool taur_flag = updateValue< std::vector< double > >( d, names::tau_rise, tau_rise ); bool taud_flag = updateValue< std::vector< double > >( d, names::tau_decay, tau_decay ); - if ( Erev_flag || taur_flag || taud_flag ) + if ( Erev_flag or taur_flag or taud_flag ) { // receptor arrays have been modified - if ( ( E_rev.size() != old_n_receptors || tau_rise.size() != old_n_receptors - || tau_decay.size() != old_n_receptors ) - and ( not Erev_flag || not taur_flag || not taud_flag ) ) + if ( ( E_rev.size() != old_n_receptors or tau_rise.size() != old_n_receptors + or tau_decay.size() != old_n_receptors ) + and ( not Erev_flag or not taur_flag or not taud_flag ) ) { throw BadProperty( "If the number of receptor ports is changed, all three arrays " "E_rev, tau_rise and tau_decay must be provided." ); } - if ( ( E_rev.size() != tau_rise.size() ) || ( E_rev.size() != tau_decay.size() ) ) + if ( ( E_rev.size() != tau_rise.size() ) or ( E_rev.size() != tau_decay.size() ) ) { throw BadProperty( "The reversal potential, synaptic rise time and synaptic decay time " @@ -245,7 +245,7 @@ aeif_cond_beta_multisynapse::Parameters_::set( const DictionaryDatum& d, Node* n } for ( size_t i = 0; i < tau_rise.size(); ++i ) { - if ( tau_rise[ i ] <= 0 || tau_decay[ i ] <= 0 ) + if ( tau_rise[ i ] <= 0 or tau_decay[ i ] <= 0 ) { throw BadProperty( "All synaptic time constants must be strictly positive" ); } @@ -533,7 +533,7 @@ aeif_cond_beta_multisynapse::update( Time const& origin, const long from, const } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } @@ -583,7 +583,7 @@ aeif_cond_beta_multisynapse::update( Time const& origin, const long from, const port aeif_cond_beta_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index dde180c7e7..6bfd606e76 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -270,7 +270,7 @@ nest::aeif_cond_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_syn_ex <= 0 || tau_syn_in <= 0 || tau_w <= 0 ) + if ( tau_syn_ex <= 0 or tau_syn_in <= 0 or tau_w <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/aeif_psc_alpha.cpp b/models/aeif_psc_alpha.cpp index 6ae94934eb..37b45b808b 100644 --- a/models/aeif_psc_alpha.cpp +++ b/models/aeif_psc_alpha.cpp @@ -261,7 +261,7 @@ nest::aeif_psc_alpha::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_syn_ex <= 0 || tau_syn_in <= 0 || tau_w <= 0 ) + if ( tau_syn_ex <= 0 or tau_syn_in <= 0 or tau_w <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } @@ -292,7 +292,7 @@ nest::aeif_psc_alpha::State_::set( const DictionaryDatum& d, const Parameters_&, updateValueParam< double >( d, names::I_syn_in, y_[ I_INH ], node ); updateValueParam< double >( d, names::dI_syn_in, y_[ DI_INH ], node ); updateValueParam< double >( d, names::w, y_[ W ], node ); - if ( y_[ I_EXC ] < 0 || y_[ I_INH ] < 0 ) + if ( y_[ I_EXC ] < 0 or y_[ I_INH ] < 0 ) { throw BadProperty( "Conductances must not be negative." ); } @@ -475,7 +475,7 @@ nest::aeif_psc_alpha::update( Time const& origin, const long from, const long to } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/aeif_psc_delta.cpp b/models/aeif_psc_delta.cpp index 42fa431d60..fe69f51d23 100644 --- a/models/aeif_psc_delta.cpp +++ b/models/aeif_psc_delta.cpp @@ -451,7 +451,7 @@ nest::aeif_psc_delta::update( const Time& origin, const long from, const long to throw GSLSolverFailure( get_name(), status ); } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index 648847a80c..ecff2ba722 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -98,7 +98,7 @@ nest::aeif_psc_delta_clopath_dynamics( double, const double y[], double f[], voi // Clamp membrane potential to V_reset while refractory, otherwise bound // it to V_peak. - const double& V = ( is_refractory || is_clamped ) ? ( is_clamped ? node.P_.V_clamp_ : node.P_.V_reset_ ) + const double& V = ( is_refractory or is_clamped ) ? ( is_clamped ? node.P_.V_clamp_ : node.P_.V_reset_ ) : std::min( y[ S::V_M ], node.P_.V_peak_ ); // shorthand for the other state variables const double& w = y[ S::W ]; @@ -112,7 +112,7 @@ nest::aeif_psc_delta_clopath_dynamics( double, const double y[], double f[], voi node.P_.Delta_T == 0. ? 0. : ( node.P_.g_L * node.P_.Delta_T * std::exp( ( V - V_th ) / node.P_.Delta_T ) ); // dv/dt - f[ S::V_M ] = ( is_refractory || is_clamped ) + f[ S::V_M ] = ( is_refractory or is_clamped ) ? 0.0 : ( -node.P_.g_L * ( V - node.P_.E_L ) + I_spike - w + z + node.P_.I_e + node.B_.I_stim_ ) / node.P_.C_m; diff --git a/models/aeif_psc_exp.cpp b/models/aeif_psc_exp.cpp index 2e61bfae9e..78d390045b 100644 --- a/models/aeif_psc_exp.cpp +++ b/models/aeif_psc_exp.cpp @@ -260,7 +260,7 @@ nest::aeif_psc_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_syn_ex <= 0 || tau_syn_in <= 0 || tau_w <= 0 ) + if ( tau_syn_ex <= 0 or tau_syn_in <= 0 or tau_w <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } @@ -287,7 +287,7 @@ nest::aeif_psc_exp::State_::set( const DictionaryDatum& d, const Parameters_&, N updateValueParam< double >( d, names::I_syn_ex, y_[ I_EXC ], node ); updateValueParam< double >( d, names::I_syn_in, y_[ I_INH ], node ); updateValueParam< double >( d, names::w, y_[ W ], node ); - if ( y_[ I_EXC ] < 0 || y_[ I_INH ] < 0 ) + if ( y_[ I_EXC ] < 0 or y_[ I_INH ] < 0 ) { throw BadProperty( "Conductances must not be negative." ); } @@ -465,7 +465,7 @@ nest::aeif_psc_exp::update( const Time& origin, const long from, const long to ) } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/amat2_psc_exp.cpp b/models/amat2_psc_exp.cpp index 88575ef8e6..2b3cf7e0cb 100644 --- a/models/amat2_psc_exp.cpp +++ b/models/amat2_psc_exp.cpp @@ -159,18 +159,18 @@ nest::amat2_psc_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Capacitance must be strictly positive." ); } - if ( Tau_ <= 0 || tau_ex_ <= 0 || tau_in_ <= 0 || tau_ref_ <= 0 || tau_1_ <= 0 || tau_2_ <= 0 || tau_v_ <= 0 ) + if ( Tau_ <= 0 or tau_ex_ <= 0 or tau_in_ <= 0 or tau_ref_ <= 0 or tau_1_ <= 0 or tau_2_ <= 0 or tau_v_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } - if ( Tau_ == tau_ex_ || Tau_ == tau_in_ || Tau_ == tau_v_ ) + if ( Tau_ == tau_ex_ or Tau_ == tau_in_ or Tau_ == tau_v_ ) { throw BadProperty( "tau_m must differ from tau_syn_ex, tau_syn_in and tau_v. " "See note in documentation." ); } - if ( tau_v_ == tau_ex_ || tau_v_ == tau_in_ ) // tau_v_ == tau_m_ checked above + if ( tau_v_ == tau_ex_ or tau_v_ == tau_in_ ) // tau_v_ == tau_m_ checked above { throw BadProperty( "tau_v must differ from tau_syn_ex, tau_syn_in and tau_m. " diff --git a/models/cm_tree.cpp b/models/cm_tree.cpp index 969f99c254..da38d19947 100644 --- a/models/cm_tree.cpp +++ b/models/cm_tree.cpp @@ -241,14 +241,14 @@ nest::CompTree::get_compartment( const long compartment_index, Compartment* comp else { auto child_it = compartment->children.begin(); - while ( ( not r_compartment ) and child_it != compartment->children.end() ) + while ( r_compartment and child_it != compartment->children.end() ) { r_compartment = get_compartment( compartment_index, &( *child_it ), 0 ); ++child_it; } } - if ( ( not r_compartment ) and raise_flag ) + if ( r_compartment and raise_flag ) { std::string msg = "does not exist in tree"; throw UnknownCompartment( compartment_index, msg ); diff --git a/models/gif_cond_exp_multisynapse.cpp b/models/gif_cond_exp_multisynapse.cpp index ef3bfe2849..527d22c4ca 100644 --- a/models/gif_cond_exp_multisynapse.cpp +++ b/models/gif_cond_exp_multisynapse.cpp @@ -210,10 +210,10 @@ nest::gif_cond_exp_multisynapse::Parameters_::set( const DictionaryDatum& d, Nod const size_t old_n_receptors = n_receptors(); bool Erev_flag = updateValue< std::vector< double > >( d, names::E_rev, E_rev_ ); bool tau_flag = updateValue< std::vector< double > >( d, names::tau_syn, tau_syn_ ); - if ( Erev_flag || tau_flag ) + if ( Erev_flag or tau_flag ) { // receptor arrays have been modified - if ( ( E_rev_.size() != old_n_receptors || tau_syn_.size() != old_n_receptors ) - and ( not Erev_flag || not tau_flag ) ) + if ( ( E_rev_.size() != old_n_receptors or tau_syn_.size() != old_n_receptors ) + and ( not Erev_flag or not tau_flag ) ) { throw BadProperty( "If the number of receptor ports is changed, both arrays " diff --git a/models/glif_cond.cpp b/models/glif_cond.cpp index 90e1e787c6..64400dc0e5 100644 --- a/models/glif_cond.cpp +++ b/models/glif_cond.cpp @@ -361,7 +361,7 @@ nest::glif_cond::Parameters_::set( const DictionaryDatum& d ) bool Erev_flag = updateValue< std::vector< double > >( d, names::E_rev, E_rev_ ); // receptor arrays have been modified - if ( tau_flag || Erev_flag ) + if ( tau_flag or Erev_flag ) { if ( E_rev_.size() != tau_syn_.size() ) { @@ -768,7 +768,7 @@ nest::glif_cond::update( Time const& origin, const long from, const long to ) nest::port nest::glif_cond::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors_() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors_() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index 093a48df26..b3122c3373 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -278,12 +278,12 @@ nest::hh_cond_beta_gap_traub::Parameters_::set( const DictionaryDatum& d ) throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_rise_ex <= 0 || tau_decay_ex <= 0 || tau_rise_in <= 0 || tau_decay_in <= 0 ) + if ( tau_rise_ex <= 0 or tau_decay_ex <= 0 or tau_rise_in <= 0 or tau_decay_in <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } - if ( g_K < 0 || g_Na < 0 || g_L < 0 ) + if ( g_K < 0 or g_Na < 0 or g_L < 0 ) { throw BadProperty( "All conductances must be non-negative." ); } @@ -305,7 +305,7 @@ nest::hh_cond_beta_gap_traub::State_::set( const DictionaryDatum& d, const Param updateValue< double >( d, names::Act_m, y_[ HH_M ] ); updateValue< double >( d, names::Inact_h, y_[ HH_H ] ); updateValue< double >( d, names::Act_n, y_[ HH_N ] ); - if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/hh_cond_exp_traub.cpp b/models/hh_cond_exp_traub.cpp index bbabbcde81..34d63ce0f6 100644 --- a/models/hh_cond_exp_traub.cpp +++ b/models/hh_cond_exp_traub.cpp @@ -230,7 +230,7 @@ nest::hh_cond_exp_traub::Parameters_::set( const DictionaryDatum& d, Node* node throw BadProperty( "Capacitance must be strictly positive." ); } - if ( tau_synE <= 0 || tau_synI <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } @@ -257,7 +257,7 @@ nest::hh_cond_exp_traub::State_::set( const DictionaryDatum& d, const Parameters updateValueParam< double >( d, names::Act_m, y_[ HH_M ], node ); updateValueParam< double >( d, names::Inact_h, y_[ HH_H ], node ); updateValueParam< double >( d, names::Act_n, y_[ HH_N ], node ); - if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 or y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/iaf_chs_2007.cpp b/models/iaf_chs_2007.cpp index b71c13adb2..d0aaeb6a04 100644 --- a/models/iaf_chs_2007.cpp +++ b/models/iaf_chs_2007.cpp @@ -131,7 +131,7 @@ nest::iaf_chs_2007::Parameters_::set( const DictionaryDatum& d, State_& s, Node* { throw BadProperty( "Reset potential cannot be negative." ); } - if ( tau_epsp_ <= 0 || tau_reset_ <= 0 ) + if ( tau_epsp_ <= 0 or tau_reset_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_cond_alpha_mc.cpp b/models/iaf_cond_alpha_mc.cpp index e6b516af9e..c49d6b8557 100644 --- a/models/iaf_cond_alpha_mc.cpp +++ b/models/iaf_cond_alpha_mc.cpp @@ -408,7 +408,7 @@ nest::iaf_cond_alpha_mc::Parameters_::set( const DictionaryDatum& d, Node* node { throw BadProperty( "Capacitance (" + comp_names_[ n ].toString() + ") must be strictly positive." ); } - if ( tau_synE[ n ] <= 0 || tau_synI[ n ] <= 0 ) + if ( tau_synE[ n ] <= 0 or tau_synI[ n ] <= 0 ) { throw BadProperty( "All time constants (" + comp_names_[ n ].toString() + ") must be strictly positive." ); } diff --git a/models/iaf_cond_beta.cpp b/models/iaf_cond_beta.cpp index 3b0dd040ca..53e1faed09 100644 --- a/models/iaf_cond_beta.cpp +++ b/models/iaf_cond_beta.cpp @@ -242,7 +242,7 @@ nest::iaf_cond_beta::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_rise_ex <= 0 || tau_decay_ex <= 0 || tau_rise_in <= 0 || tau_decay_in <= 0 ) + if ( tau_rise_ex <= 0 or tau_decay_ex <= 0 or tau_rise_in <= 0 or tau_decay_in <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_cond_exp.cpp b/models/iaf_cond_exp.cpp index cd8976de5f..4ebfb49dd5 100644 --- a/models/iaf_cond_exp.cpp +++ b/models/iaf_cond_exp.cpp @@ -199,7 +199,7 @@ nest::iaf_cond_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_synE <= 0 || tau_synI <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_cond_exp_sfa_rr.cpp b/models/iaf_cond_exp_sfa_rr.cpp index 48852fc66e..4eef7ee685 100644 --- a/models/iaf_cond_exp_sfa_rr.cpp +++ b/models/iaf_cond_exp_sfa_rr.cpp @@ -231,7 +231,7 @@ nest::iaf_cond_exp_sfa_rr::Parameters_::set( const DictionaryDatum& d, Node* nod { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_synE <= 0 || tau_synI <= 0 || tau_sfa <= 0 || tau_rr <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 or tau_sfa <= 0 or tau_rr <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_psc_alpha.cpp b/models/iaf_psc_alpha.cpp index 262289b17c..95477a7018 100644 --- a/models/iaf_psc_alpha.cpp +++ b/models/iaf_psc_alpha.cpp @@ -162,7 +162,7 @@ iaf_psc_alpha::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "Membrane time constant must be > 0." ); } - if ( tau_ex_ <= 0.0 || tau_in_ <= 0.0 ) + if ( tau_ex_ <= 0.0 or tau_in_ <= 0.0 ) { throw BadProperty( "All synaptic time constants must be > 0." ); } diff --git a/models/iaf_psc_alpha_canon.cpp b/models/iaf_psc_alpha_canon.cpp index e7af99117f..dba4791bbd 100644 --- a/models/iaf_psc_alpha_canon.cpp +++ b/models/iaf_psc_alpha_canon.cpp @@ -182,7 +182,7 @@ nest::iaf_psc_alpha_canon::Parameters_::set( const DictionaryDatum& d ) { throw BadProperty( "Refractory time must be at least one time step." ); } - if ( tau_m_ <= 0 || tau_syn_ <= 0 ) + if ( tau_m_ <= 0 or tau_syn_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_psc_alpha_multisynapse.cpp b/models/iaf_psc_alpha_multisynapse.cpp index 59dc9e0595..dd44424182 100644 --- a/models/iaf_psc_alpha_multisynapse.cpp +++ b/models/iaf_psc_alpha_multisynapse.cpp @@ -388,7 +388,7 @@ iaf_psc_alpha_multisynapse::update( Time const& origin, const long from, const l port iaf_psc_alpha_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors_() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors_() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/iaf_psc_alpha_ps.cpp b/models/iaf_psc_alpha_ps.cpp index 9dec1aa519..4d331438dd 100644 --- a/models/iaf_psc_alpha_ps.cpp +++ b/models/iaf_psc_alpha_ps.cpp @@ -177,7 +177,7 @@ nest::iaf_psc_alpha_ps::Parameters_::set( const DictionaryDatum& d ) throw BadProperty( "Refractory time must be at least one time step." ); } - if ( tau_m_ <= 0 || tau_syn_ex_ <= 0 || tau_syn_in_ <= 0 ) + if ( tau_m_ <= 0 or tau_syn_ex_ <= 0 or tau_syn_in_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_psc_exp.cpp b/models/iaf_psc_exp.cpp index dbb90f9e84..a5862ba5e3 100644 --- a/models/iaf_psc_exp.cpp +++ b/models/iaf_psc_exp.cpp @@ -154,7 +154,7 @@ nest::iaf_psc_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Capacitance must be strictly positive." ); } - if ( Tau_ <= 0 || tau_ex_ <= 0 || tau_in_ <= 0 ) + if ( Tau_ <= 0 or tau_ex_ <= 0 or tau_in_ <= 0 ) { throw BadProperty( "Membrane and synapse time constants must be strictly positive." ); } diff --git a/models/iaf_psc_exp_htum.cpp b/models/iaf_psc_exp_htum.cpp index 33b9c297d2..8fabcff069 100644 --- a/models/iaf_psc_exp_htum.cpp +++ b/models/iaf_psc_exp_htum.cpp @@ -157,7 +157,7 @@ nest::iaf_psc_exp_htum::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Capacitance must be strictly positive." ); } - if ( Tau_ <= 0 || tau_ex_ <= 0 || tau_in_ <= 0 || tau_ref_tot_ <= 0 || tau_ref_abs_ <= 0 ) + if ( Tau_ <= 0 or tau_ex_ <= 0 or tau_in_ <= 0 or tau_ref_tot_ <= 0 or tau_ref_abs_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_psc_exp_multisynapse.cpp b/models/iaf_psc_exp_multisynapse.cpp index 60445392ca..96ecd7bfe9 100644 --- a/models/iaf_psc_exp_multisynapse.cpp +++ b/models/iaf_psc_exp_multisynapse.cpp @@ -356,7 +356,7 @@ iaf_psc_exp_multisynapse::update( const Time& origin, const long from, const lon port iaf_psc_exp_multisynapse::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors_() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors_() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/iaf_psc_exp_ps.cpp b/models/iaf_psc_exp_ps.cpp index fdbba30835..6639e5bf99 100644 --- a/models/iaf_psc_exp_ps.cpp +++ b/models/iaf_psc_exp_ps.cpp @@ -178,7 +178,7 @@ nest::iaf_psc_exp_ps::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time must be at least one time step." ); } - if ( tau_m_ <= 0 || tau_ex_ <= 0 || tau_in_ <= 0 ) + if ( tau_m_ <= 0 or tau_ex_ <= 0 || tau_in_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/multimeter.cpp b/models/multimeter.cpp index 28aa313501..fd367ee3da 100644 --- a/models/multimeter.cpp +++ b/models/multimeter.cpp @@ -107,7 +107,7 @@ void nest::multimeter::Parameters_::set( const DictionaryDatum& d, const Buffers_& b, Node* node ) { if ( b.has_targets_ - and ( d->known( names::interval ) || d->known( names::offset ) || d->known( names::record_from ) ) ) + and ( d->known( names::interval ) or d->known( names::offset ) or d->known( names::record_from ) ) ) { throw BadProperty( "The recording interval, the interval offset and the list of properties " @@ -183,7 +183,7 @@ multimeter::update( Time const& origin, const long from, const long ) previous slice if we are called at the beginning of the slice. Otherwise, we do nothing. */ - if ( origin.get_steps() == 0 || from != 0 ) + if ( origin.get_steps() == 0 or from != 0 ) { return; } diff --git a/models/music_cont_out_proxy.cpp b/models/music_cont_out_proxy.cpp index 25466e65c1..d03ac81984 100644 --- a/models/music_cont_out_proxy.cpp +++ b/models/music_cont_out_proxy.cpp @@ -122,7 +122,7 @@ nest::music_cont_out_proxy::Parameters_::set( const DictionaryDatum& d, updateValue< string >( d, names::port_name, port_name_ ); } - if ( buffers.has_targets_ and ( d->known( names::interval ) || d->known( names::record_from ) ) ) + if ( buffers.has_targets_ and ( d->known( names::interval ) or d->known( names::record_from ) ) ) { throw BadProperty( "The recording interval and the list of properties to record " @@ -341,7 +341,7 @@ nest::music_cont_out_proxy::update( Time const& origin, const long from, const l the previous slice if we are called at the beginning of the slice. Otherwise, we do nothing. */ - if ( origin.get_steps() == 0 || from != 0 ) + if ( origin.get_steps() == 0 or from != 0 ) { return; } diff --git a/models/poisson_generator_ps.cpp b/models/poisson_generator_ps.cpp index adc9bded56..b59c82f915 100644 --- a/models/poisson_generator_ps.cpp +++ b/models/poisson_generator_ps.cpp @@ -181,7 +181,7 @@ nest::poisson_generator_ps::update( Time const& T, const long from, const long t assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); - if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) + if ( P_.rate_ <= 0 or P_.num_targets_ == 0 ) { return; } diff --git a/models/pp_cond_exp_mc_urbanczik.cpp b/models/pp_cond_exp_mc_urbanczik.cpp index 682f3e6c0f..c8718f9a82 100644 --- a/models/pp_cond_exp_mc_urbanczik.cpp +++ b/models/pp_cond_exp_mc_urbanczik.cpp @@ -410,7 +410,7 @@ nest::pp_cond_exp_mc_urbanczik::Parameters_::set( const DictionaryDatum& d ) throw BadProperty( "Capacitance (" + comp_names_[ n ].toString() + ") must be strictly positive." ); } - if ( urbanczik_params.tau_syn_ex[ n ] <= 0 || urbanczik_params.tau_syn_in[ n ] <= 0 ) + if ( urbanczik_params.tau_syn_ex[ n ] <= 0 or urbanczik_params.tau_syn_in[ n ] <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/ppd_sup_generator.cpp b/models/ppd_sup_generator.cpp index 4ae9416d28..b2ab069ef8 100644 --- a/models/ppd_sup_generator.cpp +++ b/models/ppd_sup_generator.cpp @@ -69,7 +69,7 @@ nest::ppd_sup_generator::Age_distribution_::update( double hazard_step, RngPtr r of thumb, this approximation is good if n >= 20 and p <= 0.05, or if n >= 100 and np <= 10. Source: http://en.wikipedia.org/wiki/Binomial_distribution#Poisson_approximation */ - if ( ( occ_active_ >= 100 and hazard_step <= 0.01 ) || ( occ_active_ >= 500 and hazard_step * occ_active_ <= 0.1 ) ) + if ( ( occ_active_ >= 100 and hazard_step <= 0.01 ) or ( occ_active_ >= 500 and hazard_step * occ_active_ <= 0.1 ) ) { poisson_distribution::param_type param( hazard_step * occ_active_ ); n_spikes = poisson_dist_( rng, param ); @@ -234,7 +234,7 @@ nest::ppd_sup_generator::update( Time const& T, const long from, const long to ) assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); - if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) + if ( P_.rate_ <= 0 or P_.num_targets_ == 0 ) { return; } @@ -249,7 +249,7 @@ nest::ppd_sup_generator::update( Time const& T, const long from, const long to ) } // get current (time-dependent) hazard rate and store it. - if ( P_.amplitude_ > 0.0 and ( P_.frequency_ > 0.0 || P_.frequency_ < 0.0 ) ) + if ( P_.amplitude_ > 0.0 and ( P_.frequency_ > 0.0 or P_.frequency_ < 0.0 ) ) { double t_ms = t.get_ms(); V_.hazard_step_t_ = V_.hazard_step_ * ( 1.0 + P_.amplitude_ * std::sin( V_.omega_ * t_ms ) ); diff --git a/models/spike_generator.cpp b/models/spike_generator.cpp index 24fd65e348..55e856de3a 100644 --- a/models/spike_generator.cpp +++ b/models/spike_generator.cpp @@ -68,7 +68,7 @@ nest::spike_generator::Parameters_::get( DictionaryDatum& d ) const const size_t n_spikes = spike_stamps_.size(); const size_t n_offsets = spike_offsets_.size(); - assert( ( precise_times_ and n_offsets == n_spikes ) || ( not precise_times_ and n_offsets == 0 ) ); + assert( ( precise_times_ and n_offsets == n_spikes ) or ( not precise_times_ and n_offsets == 0 ) ); auto* times_ms = new std::vector< double >(); times_ms->reserve( n_spikes ); @@ -143,7 +143,7 @@ nest::spike_generator::Parameters_::assert_valid_spike_time_and_insert_( double // The second part of the test handles subnormal values of offset. if ( ( std::fabs( offset ) < std::numeric_limits< double >::epsilon() * std::fabs( t_spike.get_ms() + t ) * 2.0 ) - || ( std::fabs( offset ) < std::numeric_limits< double >::min() ) ) + or ( std::fabs( offset ) < std::numeric_limits< double >::min() ) ) { // if difference is smaller than scaled epsilon it is zero offset = 0.0; @@ -165,7 +165,7 @@ nest::spike_generator::Parameters_::set( const DictionaryDatum& d, bool allow_offgrid_times_changed = updateValueParam< bool >( d, names::allow_offgrid_times, allow_offgrid_times_, node ); bool flags_changed = precise_times_changed or shift_now_spikes_changed or allow_offgrid_times_changed; - if ( precise_times_ and ( allow_offgrid_times_ || shift_now_spikes_ ) ) + if ( precise_times_ and ( allow_offgrid_times_ or shift_now_spikes_ ) ) { throw BadProperty( "Option precise_times cannot be set to true when either " @@ -173,7 +173,7 @@ nest::spike_generator::Parameters_::set( const DictionaryDatum& d, } const bool updated_spike_times = d->known( names::spike_times ); - if ( flags_changed and not( updated_spike_times || spike_stamps_.empty() ) ) + if ( flags_changed and not( updated_spike_times or spike_stamps_.empty() ) ) { throw BadProperty( "Options can only be set together with spike times or if no " @@ -264,7 +264,7 @@ nest::spike_generator::Parameters_::set( const DictionaryDatum& d, } // Set position to start if something changed - if ( updated_spike_times || updated_spike_weights || updated_spike_multiplicities || d->known( names::origin ) ) + if ( updated_spike_times or updated_spike_weights or updated_spike_multiplicities or d->known( names::origin ) ) { s.position_ = 0; } @@ -324,9 +324,9 @@ nest::spike_generator::update( Time const& sliceT0, const long from, const long return; } - assert( not P_.precise_times_ || P_.spike_stamps_.size() == P_.spike_offsets_.size() ); - assert( P_.spike_weights_.empty() || P_.spike_stamps_.size() == P_.spike_weights_.size() ); - assert( P_.spike_multiplicities_.empty() || P_.spike_stamps_.size() == P_.spike_multiplicities_.size() ); + assert( not P_.precise_times_ or P_.spike_stamps_.size() == P_.spike_offsets_.size() ); + assert( P_.spike_weights_.empty() or P_.spike_stamps_.size() == P_.spike_weights_.size() ); + assert( P_.spike_multiplicities_.empty() or P_.spike_stamps_.size() == P_.spike_multiplicities_.size() ); const Time tstart = sliceT0 + Time::step( from ); const Time tstop = sliceT0 + Time::step( to ); diff --git a/models/tsodyks_synapse_hom.cpp b/models/tsodyks_synapse_hom.cpp index 538492a6bb..a2d1c1bf70 100644 --- a/models/tsodyks_synapse_hom.cpp +++ b/models/tsodyks_synapse_hom.cpp @@ -58,7 +58,7 @@ TsodyksHomCommonProperties::set_status( const DictionaryDatum& d, ConnectorModel CommonPropertiesHomW::set_status( d, cm ); updateValue< double >( d, names::U, U_ ); - if ( U_ > 1.0 || U_ < 0.0 ) + if ( U_ > 1.0 or U_ < 0.0 ) { throw BadProperty( "U must be in [0,1]." ); } diff --git a/nestkernel/connection_creator_impl.h b/nestkernel/connection_creator_impl.h index 6955d762ad..f293e105c0 100644 --- a/nestkernel/connection_creator_impl.h +++ b/nestkernel/connection_creator_impl.h @@ -88,7 +88,7 @@ ConnectionCreator::connect_to_target_( Iterator from, const bool without_kernel = not kernel_.get(); for ( Iterator iter = from; iter != to; ++iter ) { - if ( ( not allow_autapses_ ) and ( iter->second == tgt_ptr->get_node_id() ) ) + if ( allow_autapses_ and ( iter->second == tgt_ptr->get_node_id() ) ) { continue; } @@ -422,8 +422,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, } if ( positions.empty() - or ( ( not allow_autapses_ ) and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) - or ( ( not allow_multapses_ ) and ( positions.size() < number_of_connections_ ) ) ) + or ( allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) + or ( allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found inside mask", target_id ); throw KernelException( msg.c_str() ); @@ -443,14 +443,14 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = lottery( rng ); - if ( ( not allow_multapses_ ) and ( is_selected[ random_id ] ) ) + if ( allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index source_id = positions[ random_id ].second; - if ( ( not allow_autapses_ ) and ( source_id == target_id ) ) + if ( allow_autapses_ and ( source_id == target_id ) ) { --i; continue; @@ -473,8 +473,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, // no kernel if ( positions.empty() - or ( ( not allow_autapses_ ) and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) - or ( ( not allow_multapses_ ) and ( positions.size() < number_of_connections_ ) ) ) + or ( allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) + or ( allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found inside mask", target_id ); throw KernelException( msg.c_str() ); @@ -488,7 +488,7 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = rng->ulrand( positions.size() ); - if ( ( not allow_multapses_ ) and ( is_selected[ random_id ] ) ) + if ( allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; @@ -527,8 +527,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, const std::vector< double > target_pos_vector = target_pos.get_vector(); if ( ( positions->size() == 0 ) - or ( ( not allow_autapses_ ) and ( positions->size() == 1 ) and ( ( *positions )[ 0 ].second == target_id ) ) - or ( ( not allow_multapses_ ) and ( positions->size() < number_of_connections_ ) ) ) + or ( allow_autapses_ and ( positions->size() == 1 ) and ( ( *positions )[ 0 ].second == target_id ) ) + or ( allow_multapses_ and ( positions->size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found", target_id ); throw KernelException( msg.c_str() ); @@ -567,14 +567,14 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = lottery( rng ); - if ( ( not allow_multapses_ ) and ( is_selected[ random_id ] ) ) + if ( allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index source_id = ( *positions )[ random_id ].second; - if ( ( not allow_autapses_ ) and ( source_id == target_id ) ) + if ( allow_autapses_ and ( source_id == target_id ) ) { --i; continue; @@ -605,14 +605,14 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = rng->ulrand( positions->size() ); - if ( ( not allow_multapses_ ) and ( is_selected[ random_id ] ) ) + if ( allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index source_id = ( *positions )[ random_id ].second; - if ( ( not allow_autapses_ ) and ( source_id == target_id ) ) + if ( allow_autapses_ and ( source_id == target_id ) ) { --i; continue; @@ -719,7 +719,7 @@ ConnectionCreator::fixed_outdegree_( Layer< D >& source, } if ( target_pos_node_id_pairs.empty() - or ( ( not allow_multapses_ ) and ( target_pos_node_id_pairs.size() < number_of_connections_ ) ) ) + or ( allow_multapses_ and ( target_pos_node_id_pairs.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global source ID %1: Not enough targets found", source_id ); throw KernelException( msg.c_str() ); @@ -739,13 +739,13 @@ ConnectionCreator::fixed_outdegree_( Layer< D >& source, for ( long i = 0; i < ( long ) number_of_connections_; ++i ) { index random_id = lottery( get_rank_synced_rng() ); - if ( ( not allow_multapses_ ) and ( is_selected[ random_id ] ) ) + if ( allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index target_id = target_pos_node_id_pairs[ random_id ].second; - if ( ( not allow_autapses_ ) and ( source_id == target_id ) ) + if ( allow_autapses_ and ( source_id == target_id ) ) { --i; continue; diff --git a/nestkernel/exceptions.h b/nestkernel/exceptions.h index b24be48749..752f4193bc 100644 --- a/nestkernel/exceptions.h +++ b/nestkernel/exceptions.h @@ -1211,7 +1211,7 @@ class BackendPrepared : public KernelException { } - BackendPrepared( std::stringand backend ) + BackendPrepared( std::string&& backend ) : backend_( std::move( backend ) ) { } diff --git a/sli/sliarray.cc b/sli/sliarray.cc index 169ad674d4..b9e75d101b 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -106,7 +106,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) and ( n2d ) ) + if ( n1d and n2d ) { long n = 1 + n2d->get() - n1d->get(); @@ -130,7 +130,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) and ( n2d ) ) + if ( n1d and n2d ) { long n = 1 + static_cast< long >( n2d->get() - n1d->get() ); @@ -161,7 +161,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) and ( n2d ) and ( n3d ) ) + if ( n1d and n2d and n3d ) { long di = n3d->get(); long start = n1d->get(); @@ -192,7 +192,7 @@ SLIArrayModule::RangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) and ( n2d ) and ( n3d ) ) + if ( n1d and n2d and n3d ) { double di = n3d->get(); double start = n1d->get(); @@ -286,7 +286,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) and ( n2d ) ) + if ( n1d and n2d ) { const long start = n1d->get(); const long stop = n2d->get(); @@ -310,7 +310,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const { DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); - if ( ( n1d ) and ( n2d ) ) + if ( n1d and n2d ) { double start = n1d->get(); double stop = n2d->get(); @@ -338,7 +338,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const IntegerDatum* n1d = dynamic_cast< IntegerDatum* >( ad->get( 0 ).datum() ); IntegerDatum* n2d = dynamic_cast< IntegerDatum* >( ad->get( 1 ).datum() ); IntegerDatum* n3d = dynamic_cast< IntegerDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) and ( n2d ) and ( n3d ) ) + if ( n1d and n2d and n3d ) { long di = n3d->get(); long start = n1d->get(); @@ -372,7 +372,7 @@ SLIArrayModule::ArangeFunction::execute( SLIInterpreter* i ) const DoubleDatum* n1d = dynamic_cast< DoubleDatum* >( ad->get( 0 ).datum() ); DoubleDatum* n2d = dynamic_cast< DoubleDatum* >( ad->get( 1 ).datum() ); DoubleDatum* n3d = dynamic_cast< DoubleDatum* >( ad->get( 2 ).datum() ); - if ( ( n1d ) and ( n2d ) and ( n3d ) ) + if ( n1d and n2d and n3d ) { double di = n3d->get(); double start = n1d->get(); diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index 296cd967f9..469fd9cb71 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -1170,7 +1170,7 @@ RaiseerrorFunction::execute( SLIInterpreter* i ) const Name* errorname = dynamic_cast< Name* >( err.datum() ); Name* cmdname = dynamic_cast< Name* >( cmd.datum() ); - if ( ( not errorname ) or ( not cmdname ) ) + if ( errorname or cmdname ) { i->message( SLIInterpreter::M_ERROR, "raiseerror", "Usage: /command /errorname raiserror" ); i->raiseerror( "ArgumentType" ); diff --git a/sli/token.h b/sli/token.h index 658e245ef9..acb07077d8 100644 --- a/sli/token.h +++ b/sli/token.h @@ -341,7 +341,7 @@ class Token bool contains( const Datum& d ) const { - return ( p ) and p->equals( &d ); + return p and p->equals( &d ); } bool From 0141e1a02184733bf1ac0542c89f5bca3f21118e Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 11 Oct 2022 01:04:08 +0200 Subject: [PATCH 116/150] Added back nots that were removed by accident --- libnestutil/lockptr.h | 2 +- models/cm_tree.cpp | 4 ++-- nestkernel/connection_creator_impl.h | 32 ++++++++++++++-------------- sli/slicontrol.cc | 2 +- 4 files changed, 20 insertions(+), 20 deletions(-) diff --git a/libnestutil/lockptr.h b/libnestutil/lockptr.h index 16156afcae..21096cf20a 100644 --- a/libnestutil/lockptr.h +++ b/libnestutil/lockptr.h @@ -114,7 +114,7 @@ class lockPTR ~PointerObject() { assert( not locked ); - if ( ( pointee != NULL ) and deletable and locked ) + if ( ( pointee != NULL ) and deletable and not locked ) { delete pointee; } diff --git a/models/cm_tree.cpp b/models/cm_tree.cpp index da38d19947..25fd684ac6 100644 --- a/models/cm_tree.cpp +++ b/models/cm_tree.cpp @@ -241,14 +241,14 @@ nest::CompTree::get_compartment( const long compartment_index, Compartment* comp else { auto child_it = compartment->children.begin(); - while ( r_compartment and child_it != compartment->children.end() ) + while ( not r_compartment and child_it != compartment->children.end() ) { r_compartment = get_compartment( compartment_index, &( *child_it ), 0 ); ++child_it; } } - if ( r_compartment and raise_flag ) + if ( not r_compartment and raise_flag ) { std::string msg = "does not exist in tree"; throw UnknownCompartment( compartment_index, msg ); diff --git a/nestkernel/connection_creator_impl.h b/nestkernel/connection_creator_impl.h index f293e105c0..234fc4e6a3 100644 --- a/nestkernel/connection_creator_impl.h +++ b/nestkernel/connection_creator_impl.h @@ -88,7 +88,7 @@ ConnectionCreator::connect_to_target_( Iterator from, const bool without_kernel = not kernel_.get(); for ( Iterator iter = from; iter != to; ++iter ) { - if ( allow_autapses_ and ( iter->second == tgt_ptr->get_node_id() ) ) + if ( not allow_autapses_ and ( iter->second == tgt_ptr->get_node_id() ) ) { continue; } @@ -422,8 +422,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, } if ( positions.empty() - or ( allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) - or ( allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) + or ( not allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) + or ( not allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found inside mask", target_id ); throw KernelException( msg.c_str() ); @@ -443,7 +443,7 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = lottery( rng ); - if ( allow_multapses_ and ( is_selected[ random_id ] ) ) + if ( not allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; @@ -473,8 +473,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, // no kernel if ( positions.empty() - or ( allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) - or ( allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) + or ( not allow_autapses_ and ( positions.size() == 1 ) and ( positions[ 0 ].second == target_id ) ) + or ( not allow_multapses_ and ( positions.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found inside mask", target_id ); throw KernelException( msg.c_str() ); @@ -488,7 +488,7 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = rng->ulrand( positions.size() ); - if ( allow_multapses_ and ( is_selected[ random_id ] ) ) + if ( not allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; @@ -527,8 +527,8 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, const std::vector< double > target_pos_vector = target_pos.get_vector(); if ( ( positions->size() == 0 ) - or ( allow_autapses_ and ( positions->size() == 1 ) and ( ( *positions )[ 0 ].second == target_id ) ) - or ( allow_multapses_ and ( positions->size() < number_of_connections_ ) ) ) + or ( not allow_autapses_ and ( positions->size() == 1 ) and ( ( *positions )[ 0 ].second == target_id ) ) + or ( not allow_multapses_ and ( positions->size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global target ID %1: Not enough sources found", target_id ); throw KernelException( msg.c_str() ); @@ -567,14 +567,14 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = lottery( rng ); - if ( allow_multapses_ and ( is_selected[ random_id ] ) ) + if ( not allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index source_id = ( *positions )[ random_id ].second; - if ( allow_autapses_ and ( source_id == target_id ) ) + if ( not allow_autapses_ and ( source_id == target_id ) ) { --i; continue; @@ -605,14 +605,14 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, for ( int i = 0; i < ( int ) number_of_connections_; ++i ) { index random_id = rng->ulrand( positions->size() ); - if ( allow_multapses_ and ( is_selected[ random_id ] ) ) + if ( not allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index source_id = ( *positions )[ random_id ].second; - if ( allow_autapses_ and ( source_id == target_id ) ) + if ( not allow_autapses_ and ( source_id == target_id ) ) { --i; continue; @@ -719,7 +719,7 @@ ConnectionCreator::fixed_outdegree_( Layer< D >& source, } if ( target_pos_node_id_pairs.empty() - or ( allow_multapses_ and ( target_pos_node_id_pairs.size() < number_of_connections_ ) ) ) + or ( not allow_multapses_ and ( target_pos_node_id_pairs.size() < number_of_connections_ ) ) ) { std::string msg = String::compose( "Global source ID %1: Not enough targets found", source_id ); throw KernelException( msg.c_str() ); @@ -739,13 +739,13 @@ ConnectionCreator::fixed_outdegree_( Layer< D >& source, for ( long i = 0; i < ( long ) number_of_connections_; ++i ) { index random_id = lottery( get_rank_synced_rng() ); - if ( allow_multapses_ and ( is_selected[ random_id ] ) ) + if ( not allow_multapses_ and ( is_selected[ random_id ] ) ) { --i; continue; } index target_id = target_pos_node_id_pairs[ random_id ].second; - if ( allow_autapses_ and ( source_id == target_id ) ) + if ( not allow_autapses_ and ( source_id == target_id ) ) { --i; continue; diff --git a/sli/slicontrol.cc b/sli/slicontrol.cc index 469fd9cb71..b9ccb9fa46 100644 --- a/sli/slicontrol.cc +++ b/sli/slicontrol.cc @@ -1170,7 +1170,7 @@ RaiseerrorFunction::execute( SLIInterpreter* i ) const Name* errorname = dynamic_cast< Name* >( err.datum() ); Name* cmdname = dynamic_cast< Name* >( cmd.datum() ); - if ( errorname or cmdname ) + if ( not errorname or not cmdname ) { i->message( SLIInterpreter::M_ERROR, "raiseerror", "Usage: /command /errorname raiserror" ); i->raiseerror( "ArgumentType" ); From cccd1fa03a45b6449037f9312de354a760379db4 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 11 Oct 2022 11:26:50 +0200 Subject: [PATCH 117/150] Added one more not --- nestkernel/connection_creator_impl.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nestkernel/connection_creator_impl.h b/nestkernel/connection_creator_impl.h index 234fc4e6a3..54c57f2f33 100644 --- a/nestkernel/connection_creator_impl.h +++ b/nestkernel/connection_creator_impl.h @@ -450,7 +450,7 @@ ConnectionCreator::fixed_indegree_( Layer< D >& source, } index source_id = positions[ random_id ].second; - if ( allow_autapses_ and ( source_id == target_id ) ) + if ( not allow_autapses_ and ( source_id == target_id ) ) { --i; continue; From de105ec9a13b6943ec1db8bace5fb6a0894698f2 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Tue, 11 Oct 2022 18:00:25 +0200 Subject: [PATCH 118/150] Fixed all remaining occurrences of || and && --- models/aeif_cond_alpha.cpp | 6 ++-- models/aeif_cond_exp.cpp | 4 +-- models/aeif_psc_delta_clopath.cpp | 2 +- models/correlomatrix_detector.cpp | 4 +-- models/gamma_sup_generator.cpp | 4 +-- models/gif_cond_exp.cpp | 2 +- models/gif_psc_exp.cpp | 2 +- models/glif_psc.cpp | 2 +- models/hh_cond_beta_gap_traub.cpp | 2 +- models/hh_psc_alpha.cpp | 6 ++-- models/hh_psc_alpha_clopath.cpp | 2 +- models/hh_psc_alpha_gap.cpp | 6 ++-- models/iaf_cond_alpha.cpp | 2 +- models/iaf_psc_exp_ps.cpp | 2 +- models/mat2_psc_exp.cpp | 4 +-- models/mip_generator.cpp | 2 +- nestkernel/clopath_archiving_node.cpp | 2 +- sli/sliarray.cc | 2 +- sli/slidata.cc | 50 +++++++++++++-------------- 19 files changed, 53 insertions(+), 53 deletions(-) diff --git a/models/aeif_cond_alpha.cpp b/models/aeif_cond_alpha.cpp index 60038d1bb4..1d2be29e75 100644 --- a/models/aeif_cond_alpha.cpp +++ b/models/aeif_cond_alpha.cpp @@ -271,7 +271,7 @@ nest::aeif_cond_alpha::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_syn_ex <= 0 || tau_syn_in <= 0 || tau_w <= 0 ) + if ( tau_syn_ex <= 0 or tau_syn_in <= 0 or tau_w <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } @@ -302,7 +302,7 @@ nest::aeif_cond_alpha::State_::set( const DictionaryDatum& d, const Parameters_& updateValueParam< double >( d, names::g_in, y_[ G_INH ], node ); updateValueParam< double >( d, names::dg_in, y_[ DG_INH ], node ); updateValueParam< double >( d, names::w, y_[ W ], node ); - if ( y_[ G_EXC ] < 0 || y_[ G_INH ] < 0 ) + if ( y_[ G_EXC ] < 0 or y_[ G_INH ] < 0 ) { throw BadProperty( "Conductances must not be negative." ); } @@ -485,7 +485,7 @@ nest::aeif_cond_alpha::update( Time const& origin, const long from, const long t } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/aeif_cond_exp.cpp b/models/aeif_cond_exp.cpp index 6bfd606e76..5bdeef5b46 100644 --- a/models/aeif_cond_exp.cpp +++ b/models/aeif_cond_exp.cpp @@ -297,7 +297,7 @@ nest::aeif_cond_exp::State_::set( const DictionaryDatum& d, const Parameters_&, updateValueParam< double >( d, names::g_ex, y_[ G_EXC ], node ); updateValueParam< double >( d, names::g_in, y_[ G_INH ], node ); updateValueParam< double >( d, names::w, y_[ W ], node ); - if ( y_[ G_EXC ] < 0 || y_[ G_INH ] < 0 ) + if ( y_[ G_EXC ] < 0 or y_[ G_INH ] < 0 ) { throw BadProperty( "Conductances must not be negative." ); } @@ -475,7 +475,7 @@ nest::aeif_cond_exp::update( const Time& origin, const long from, const long to } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/aeif_psc_delta_clopath.cpp b/models/aeif_psc_delta_clopath.cpp index ecff2ba722..e247a30f07 100644 --- a/models/aeif_psc_delta_clopath.cpp +++ b/models/aeif_psc_delta_clopath.cpp @@ -509,7 +509,7 @@ nest::aeif_psc_delta_clopath::update( const Time& origin, const long from, const throw GSLSolverFailure( get_name(), status ); } // check for unreasonable values; we allow V_M to explode - if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 ) + if ( S_.y_[ State_::V_M ] < -1e3 or S_.y_[ State_::W ] < -1e6 or S_.y_[ State_::W ] > 1e6 ) { throw NumericalInstability( get_name() ); } diff --git a/models/correlomatrix_detector.cpp b/models/correlomatrix_detector.cpp index 44de2f8466..7964f2942c 100644 --- a/models/correlomatrix_detector.cpp +++ b/models/correlomatrix_detector.cpp @@ -371,14 +371,14 @@ nest::correlomatrix_detector::handle( SpikeEvent& e ) { // weighted histogram S_.covariance_[ sender_ind ][ other_ind ][ bin ] += e.get_multiplicity() * e.get_weight() * spike_j->weight_; - if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) + if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 or other != sender ) ) { S_.covariance_[ other_ind ][ sender_ind ][ bin ] += e.get_multiplicity() * e.get_weight() * spike_j->weight_; } // pure (unweighted) count histogram S_.count_covariance_[ sender_ind ][ other_ind ][ bin ] += e.get_multiplicity(); - if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 || other != sender ) ) + if ( bin == 0 and ( spike_i - spike_j->timestep_ != 0 or other != sender ) ) { S_.count_covariance_[ other_ind ][ sender_ind ][ bin ] += e.get_multiplicity(); } diff --git a/models/gamma_sup_generator.cpp b/models/gamma_sup_generator.cpp index 5e52a18634..9763dc0b43 100644 --- a/models/gamma_sup_generator.cpp +++ b/models/gamma_sup_generator.cpp @@ -78,7 +78,7 @@ nest::gamma_sup_generator::Internal_states_::update( double transition_prob, Rng http://en.wikipedia.org/wiki/Binomial_distribution#Poisson_approximation */ if ( ( occ_[ i ] >= 100 and transition_prob <= 0.01 ) - || ( occ_[ i ] >= 500 and transition_prob * occ_[ i ] <= 0.1 ) ) + or ( occ_[ i ] >= 500 and transition_prob * occ_[ i ] <= 0.1 ) ) { poisson_distribution::param_type param( transition_prob * occ_[ i ] ); n_trans[ i ] = poisson_dist_( rng, param ); @@ -235,7 +235,7 @@ nest::gamma_sup_generator::update( Time const& T, const long from, const long to assert( to >= 0 and ( delay ) from < kernel().connection_manager.get_min_delay() ); assert( from < to ); - if ( P_.rate_ <= 0 || P_.num_targets_ == 0 ) + if ( P_.rate_ <= 0 or P_.num_targets_ == 0 ) { return; } diff --git a/models/gif_cond_exp.cpp b/models/gif_cond_exp.cpp index 9192938617..95592e1424 100644 --- a/models/gif_cond_exp.cpp +++ b/models/gif_cond_exp.cpp @@ -312,7 +312,7 @@ nest::gif_cond_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "All time constants must be strictly positive." ); } } - if ( tau_synE_ <= 0 || tau_synI_ <= 0 ) + if ( tau_synE_ <= 0 or tau_synI_ <= 0 ) { throw BadProperty( "Synapse time constants must be strictly positive." ); } diff --git a/models/gif_psc_exp.cpp b/models/gif_psc_exp.cpp index ee63f2fa28..4c7193d591 100644 --- a/models/gif_psc_exp.cpp +++ b/models/gif_psc_exp.cpp @@ -213,7 +213,7 @@ nest::gif_psc_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) throw BadProperty( "All time constants must be strictly positive." ); } } - if ( tau_ex_ <= 0 || tau_in_ <= 0 ) + if ( tau_ex_ <= 0 or tau_in_ <= 0 ) { throw BadProperty( "Synapse time constants must be strictly positive." ); } diff --git a/models/glif_psc.cpp b/models/glif_psc.cpp index f4d9664afb..ef2e434a3f 100644 --- a/models/glif_psc.cpp +++ b/models/glif_psc.cpp @@ -601,7 +601,7 @@ nest::glif_psc::update( Time const& origin, const long from, const long to ) nest::port nest::glif_psc::handles_test_event( SpikeEvent&, rport receptor_type ) { - if ( receptor_type <= 0 || receptor_type > static_cast< port >( P_.n_receptors_() ) ) + if ( receptor_type <= 0 or receptor_type > static_cast< port >( P_.n_receptors_() ) ) { throw IncompatibleReceptorType( receptor_type, get_name(), "SpikeEvent" ); } diff --git a/models/hh_cond_beta_gap_traub.cpp b/models/hh_cond_beta_gap_traub.cpp index b3122c3373..e4ef255efa 100644 --- a/models/hh_cond_beta_gap_traub.cpp +++ b/models/hh_cond_beta_gap_traub.cpp @@ -305,7 +305,7 @@ nest::hh_cond_beta_gap_traub::State_::set( const DictionaryDatum& d, const Param updateValue< double >( d, names::Act_m, y_[ HH_M ] ); updateValue< double >( d, names::Inact_h, y_[ HH_H ] ); updateValue< double >( d, names::Act_n, y_[ HH_N ] ); - if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 or y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/hh_psc_alpha.cpp b/models/hh_psc_alpha.cpp index 0c0f7e710d..63598a5e2d 100644 --- a/models/hh_psc_alpha.cpp +++ b/models/hh_psc_alpha.cpp @@ -227,11 +227,11 @@ nest::hh_psc_alpha::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_synE <= 0 || tau_synI <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } - if ( g_K < 0 || g_Na < 0 || g_L < 0 ) + if ( g_K < 0 or g_Na < 0 or g_L < 0 ) { throw BadProperty( "All conductances must be non-negative." ); } @@ -253,7 +253,7 @@ nest::hh_psc_alpha::State_::set( const DictionaryDatum& d, Node* node ) updateValueParam< double >( d, names::Act_m, y_[ HH_M ], node ); updateValueParam< double >( d, names::Inact_h, y_[ HH_H ], node ); updateValueParam< double >( d, names::Act_n, y_[ HH_N ], node ); - if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 or y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/hh_psc_alpha_clopath.cpp b/models/hh_psc_alpha_clopath.cpp index f476ecd83b..66b0b541b1 100644 --- a/models/hh_psc_alpha_clopath.cpp +++ b/models/hh_psc_alpha_clopath.cpp @@ -279,7 +279,7 @@ nest::hh_psc_alpha_clopath::State_::set( const DictionaryDatum& d, Node* node ) updateValueParam< double >( d, names::u_bar_plus, y_[ U_BAR_PLUS ], node ); updateValueParam< double >( d, names::u_bar_minus, y_[ U_BAR_MINUS ], node ); updateValueParam< double >( d, names::u_bar_bar, y_[ U_BAR_BAR ], node ); - if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 or y_[ HH_N ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/hh_psc_alpha_gap.cpp b/models/hh_psc_alpha_gap.cpp index cf5a715624..73fc683801 100644 --- a/models/hh_psc_alpha_gap.cpp +++ b/models/hh_psc_alpha_gap.cpp @@ -267,11 +267,11 @@ nest::hh_psc_alpha_gap::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_synE <= 0 || tau_synI <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } - if ( g_Kv1 < 0 || g_Kv3 < 0 || g_Na < 0 || g_L < 0 ) + if ( g_Kv1 < 0 or g_Kv3 < 0 or g_Na < 0 or g_L < 0 ) { throw BadProperty( "All conductances must be non-negative." ); } @@ -295,7 +295,7 @@ nest::hh_psc_alpha_gap::State_::set( const DictionaryDatum& d, Node* node ) updateValueParam< double >( d, names::Inact_h, y_[ HH_H ], node ); updateValueParam< double >( d, names::Act_n, y_[ HH_N ], node ); updateValueParam< double >( d, names::Inact_p, y_[ HH_P ], node ); - if ( y_[ HH_M ] < 0 || y_[ HH_H ] < 0 || y_[ HH_N ] < 0 || y_[ HH_P ] < 0 ) + if ( y_[ HH_M ] < 0 or y_[ HH_H ] < 0 or y_[ HH_N ] < 0 or y_[ HH_P ] < 0 ) { throw BadProperty( "All (in)activation variables must be non-negative." ); } diff --git a/models/iaf_cond_alpha.cpp b/models/iaf_cond_alpha.cpp index 91c69c6b4a..a2cfb5ca4e 100644 --- a/models/iaf_cond_alpha.cpp +++ b/models/iaf_cond_alpha.cpp @@ -235,7 +235,7 @@ nest::iaf_cond_alpha::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time cannot be negative." ); } - if ( tau_synE <= 0 || tau_synI <= 0 ) + if ( tau_synE <= 0 or tau_synI <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/iaf_psc_exp_ps.cpp b/models/iaf_psc_exp_ps.cpp index 6639e5bf99..0aea0ab0c1 100644 --- a/models/iaf_psc_exp_ps.cpp +++ b/models/iaf_psc_exp_ps.cpp @@ -178,7 +178,7 @@ nest::iaf_psc_exp_ps::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Refractory time must be at least one time step." ); } - if ( tau_m_ <= 0 or tau_ex_ <= 0 || tau_in_ <= 0 ) + if ( tau_m_ <= 0 or tau_ex_ <= 0 or tau_in_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } diff --git a/models/mat2_psc_exp.cpp b/models/mat2_psc_exp.cpp index 3bf8cca57d..d17f50cbab 100644 --- a/models/mat2_psc_exp.cpp +++ b/models/mat2_psc_exp.cpp @@ -148,11 +148,11 @@ nest::mat2_psc_exp::Parameters_::set( const DictionaryDatum& d, Node* node ) { throw BadProperty( "Capacitance must be strictly positive." ); } - if ( Tau_ <= 0 || tau_ex_ <= 0 || tau_in_ <= 0 || tau_ref_ <= 0 || tau_1_ <= 0 || tau_2_ <= 0 ) + if ( Tau_ <= 0 or tau_ex_ <= 0 or tau_in_ <= 0 or tau_ref_ <= 0 or tau_1_ <= 0 or tau_2_ <= 0 ) { throw BadProperty( "All time constants must be strictly positive." ); } - if ( Tau_ == tau_ex_ || Tau_ == tau_in_ ) + if ( Tau_ == tau_ex_ or Tau_ == tau_in_ ) { throw BadProperty( "Membrane and synapse time constant(s) must differ." diff --git a/models/mip_generator.cpp b/models/mip_generator.cpp index 5f03338517..b254517c7a 100644 --- a/models/mip_generator.cpp +++ b/models/mip_generator.cpp @@ -124,7 +124,7 @@ nest::mip_generator::update( Time const& T, const long from, const long to ) for ( long lag = from; lag < to; ++lag ) { - if ( not StimulationDevice::is_active( T ) || P_.rate_ <= 0 ) + if ( not StimulationDevice::is_active( T ) or P_.rate_ <= 0 ) { return; // no spikes to be generated } diff --git a/nestkernel/clopath_archiving_node.cpp b/nestkernel/clopath_archiving_node.cpp index 66c6f221fa..8d2f63e77a 100644 --- a/nestkernel/clopath_archiving_node.cpp +++ b/nestkernel/clopath_archiving_node.cpp @@ -134,7 +134,7 @@ double nest::ClopathArchivingNode::get_LTD_value( double t ) { std::vector< histentry_extended >::iterator runner; - if ( ltd_history_.empty() || t < 0.0 ) + if ( ltd_history_.empty() or t < 0.0 ) { return 0.0; } diff --git a/sli/sliarray.cc b/sli/sliarray.cc index b9e75d101b..cddfa51a51 100644 --- a/sli/sliarray.cc +++ b/sli/sliarray.cc @@ -3930,7 +3930,7 @@ SLIArrayModule::FiniteQ_dFunction::execute( SLIInterpreter* i ) const i->assert_stack_load( 1 ); const double x = getValue< double >( i->OStack.pick( 0 ) ); - BoolDatum res( -std::numeric_limits< double >::max() <= x && x <= std::numeric_limits< double >::max() ); + BoolDatum res( -std::numeric_limits< double >::max() <= x and x <= std::numeric_limits< double >::max() ); i->OStack.push( res ); i->EStack.pop(); } diff --git a/sli/slidata.cc b/sli/slidata.cc index a359403f3d..a1041a3afe 100644 --- a/sli/slidata.cc +++ b/sli/slidata.cc @@ -652,9 +652,9 @@ Erase_aFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 and id && n ); + assert( s1 and id and n ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { if ( n->get() >= 0 ) { @@ -683,9 +683,9 @@ Erase_pFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* n = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && n ); + assert( s1 and id and n ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { if ( n->get() >= 0 ) { @@ -715,9 +715,9 @@ Put_sFunction::execute( SLIInterpreter* i ) const IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && id && cd ); + assert( s1 and id and cd ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < s1->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < s1->size() ) ) { i->EStack.pop(); ( *s1 )[ id->get() ] = static_cast< char >( cd->get() ); @@ -739,9 +739,9 @@ Put_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad && id ); + assert( ad and id ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < ad->size() ) ) { i->EStack.pop(); ad->assign_move( id->get(), i->OStack.top() ); // its safe to empty top() because @@ -763,9 +763,9 @@ Put_pFunction::execute( SLIInterpreter* i ) const ProcedureDatum* ad = dynamic_cast< ProcedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad && id ); + assert( ad and id ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < ad->size() ) ) { i->EStack.pop(); ad->assign_move( id->get(), i->OStack.top() ); // its safe to empty top() because @@ -787,9 +787,9 @@ Put_lpFunction::execute( SLIInterpreter* i ) const LitprocedureDatum* ad = dynamic_cast< LitprocedureDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); - assert( ad && id ); + assert( ad and id ); - if ( ( id->get() >= 0 ) && ( ( size_t ) id->get() < ad->size() ) ) + if ( ( id->get() >= 0 ) and ( ( size_t ) id->get() < ad->size() ) ) { i->EStack.pop(); ad->assign_move( id->get(), i->OStack.top() ); // its safe to empty top() because @@ -983,7 +983,7 @@ Reserve_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad && id ); + assert( ad and id ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1018,7 +1018,7 @@ Resize_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* ad = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad && id ); + assert( ad and id ); if ( id->get() >= 0 ) { i->EStack.pop(); @@ -1135,7 +1135,7 @@ Reserve_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad && id ); + assert( ad and id ); if ( id->get() >= 0 ) { @@ -1158,7 +1158,7 @@ Resize_sFunction::execute( SLIInterpreter* i ) const StringDatum* ad = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( ad && id ); + assert( ad and id ); if ( id->get() >= 0 ) { @@ -1229,12 +1229,12 @@ Getinterval_sFunction::execute( SLIInterpreter* i ) const StringDatum* sd = dynamic_cast< StringDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd && id && cd ); + assert( sd and id and cd ); if ( cd->get() >= 0 ) { - if ( id->get() >= 0 && static_cast< size_t >( id->get() ) < sd->size() - && static_cast< size_t >( id->get() + cd->get() ) <= sd->size() ) + if ( id->get() >= 0 and static_cast< size_t >( id->get() ) < sd->size() + and static_cast< size_t >( id->get() + cd->get() ) <= sd->size() ) { i->EStack.pop(); sd->assign( *sd, id->get(), cd->get() ); @@ -1261,13 +1261,13 @@ Getinterval_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* sd = dynamic_cast< ArrayDatum* >( i->OStack.pick( 2 ).datum() ); IntegerDatum* id = dynamic_cast< IntegerDatum* >( i->OStack.pick( 1 ).datum() ); IntegerDatum* cd = dynamic_cast< IntegerDatum* >( i->OStack.pick( 0 ).datum() ); - assert( sd && id && cd ); + assert( sd and id and cd ); if ( cd->get() >= 0 ) { - if ( id->get() >= 0 && static_cast< size_t >( id->get() ) < sd->size() - && static_cast< size_t >( id->get() + cd->get() ) <= sd->size() ) + if ( id->get() >= 0 and static_cast< size_t >( id->get() ) < sd->size() + and static_cast< size_t >( id->get() + cd->get() ) <= sd->size() ) { i->EStack.pop(); sd->reduce( id->get(), cd->get() ); @@ -1403,7 +1403,7 @@ Get_sFunction::execute( SLIInterpreter* i ) const assert( obj ); - if ( ( idx->get() >= 0 ) && ( ( size_t ) idx->get() < obj->size() ) ) + if ( ( idx->get() >= 0 ) and ( ( size_t ) idx->get() < obj->size() ) ) { i->EStack.pop(); Token objT( new IntegerDatum( ( *obj )[ idx->get() ] ) ); @@ -1439,7 +1439,7 @@ Search_sFunction::execute( SLIInterpreter* i ) const StringDatum* s1 = dynamic_cast< StringDatum* >( i->OStack.pick( 1 ).datum() ); StringDatum* s2 = dynamic_cast< StringDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && s2 ); + assert( s1 and s2 ); size_t p = s1->find( *s2 ); @@ -1474,7 +1474,7 @@ Search_aFunction::execute( SLIInterpreter* i ) const ArrayDatum* s1 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 1 ).datum() ); ArrayDatum* s2 = dynamic_cast< ArrayDatum* >( i->OStack.pick( 0 ).datum() ); - assert( s1 && s2 ); + assert( s1 and s2 ); Token* p = std::search( s1->begin(), s1->end(), s2->begin(), s2->end() ); From d1bf1fb55822b8d6973e03e20b274e5bc54c89a8 Mon Sep 17 00:00:00 2001 From: clinssen Date: Wed, 12 Oct 2022 08:56:13 +0200 Subject: [PATCH 119/150] update docstring note about PYNEST_QUIET based on review Co-authored-by: jessica-mitchell --- pynest/nest/lib/hl_api_info.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index 0eefd4f72e..22421c4741 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -202,8 +202,8 @@ def set_verbosity(level): .. note:: - To suppress the usual output when NEST starts up (e.g. the welcome message and - version information) you can run ``export PYNEST_QUIET=1`` on the command + To suppress the usual output when NEST starts up (e.g., the welcome message and + version information), you can run ``export PYNEST_QUIET=1`` on the command line before executing your simulation script. Parameters From 5ebc205f0b6c6189e6e9c220ff173b5c9f874829 Mon Sep 17 00:00:00 2001 From: Jan Vogelsang Date: Thu, 13 Oct 2022 11:30:08 +0200 Subject: [PATCH 120/150] Fixed tokenstack, one and has to be or instead --- sli/tokenstack.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sli/tokenstack.h b/sli/tokenstack.h index 2a5d26a888..a7ccccf6f3 100644 --- a/sli/tokenstack.h +++ b/sli/tokenstack.h @@ -160,7 +160,7 @@ class TokenStack : private TokenArrayObj void roll( size_t n, long k ) { - if ( n < 2 and k == 0 ) + if ( n < 2 or k == 0 ) { return; // nothing to do } From 6dfdaa2b2f5d625f8add500bef9fcd8a8d6a7b3f Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Thu, 13 Oct 2022 16:00:10 +0200 Subject: [PATCH 121/150] Fix formatting --- nestkernel/model_manager.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/nestkernel/model_manager.cpp b/nestkernel/model_manager.cpp index 4473bdd33b..52249a936d 100644 --- a/nestkernel/model_manager.cpp +++ b/nestkernel/model_manager.cpp @@ -267,8 +267,7 @@ ModelManager::copy_connection_model_( index old_id, Name new_name ) // connection_model = 62, see nest_types.h { const std::string msg = String::compose( - "CopyModel cannot generate another synapse. Maximal synapse model count of %1 exceeded.", - MAX_SYN_ID ); + "CopyModel cannot generate another synapse. Maximal synapse model count of %1 exceeded.", MAX_SYN_ID ); LOG( M_ERROR, "ModelManager::copy_connection_model_", msg ); throw KernelException( "Synapse model count exceeded" ); } @@ -552,8 +551,7 @@ ModelManager::register_connection_model_( ConnectorModel* cf ) { delete cf; std::string msg = String::compose( - "A synapse type called '%1' already exists. Please choose a different name!", - cf->get_name() ); + "A synapse type called '%1' already exists. Please choose a different name!", cf->get_name() ); throw NamingConflict( msg ); } From a3111374347c25010b3f9c1561c6e396f1f48b93 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Mon, 17 Oct 2022 11:10:02 +0200 Subject: [PATCH 122/150] Change NEST Server default port to 52425 --- bin/nest-server | 4 +- doc/htmldoc/connect_nest/nest_server.rst | 50 ++++++++++++------------ doc/htmldoc/installation/docker.rst | 8 ++-- pynest/nest/server/hl_api_server.py | 2 +- 4 files changed, 31 insertions(+), 33 deletions(-) diff --git a/bin/nest-server b/bin/nest-server index 5eae6520db..9d8734b1b8 100755 --- a/bin/nest-server +++ b/bin/nest-server @@ -3,7 +3,7 @@ DAEMON="${NEST_SERVER_DAEMON:-0}" HOST="${NEST_SERVER_HOST:-127.0.0.1}" LOGFILE="${NEST_SERVER_LOGFILE:-/tmp/nest-server.log}" -PORT="${NEST_SERVER_PORT:-5000}" +PORT="${NEST_SERVER_PORT:-52425}" STDOUT="${NEST_SERVER_STDOUT:-0}" usage() { @@ -22,7 +22,7 @@ usage() { echo " -d daemonize the server process" echo " -h use hostname/IP address for the server [default: 127.0.0.1]" echo " -o print NEST outputs to the console" - echo " -p use port for opening the socket [default: 5000]" + echo " -p use port for opening the socket [default: 52425]" } log() { diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 54b8dc0f84..f28ceffe90 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -103,7 +103,7 @@ command that can either be run directly:: or supplied to the execution command line for running the Docker container:: - docker run -it --rm -e LOCAL_USER_ID=`id -u $USER` -p 5000:5000 nestsim/nest:latest nest-server start + docker run -it --rm -e LOCAL_USER_ID=`id -u $USER` -p 52425:52425 nestsim/nest:latest nest-server start The generic invocation command line for the ``nest-server`` command looks as follows:: @@ -120,7 +120,7 @@ of the other arguments is as follows: -h Use hostname/IP address for the server instance [default: 127.0.0.1] -p - Use port for opening the socket [default: 5000] + Use port for opening the socket [default: 52425] Run with MPI ~~~~~~~~~~~~ @@ -299,22 +299,22 @@ NEST Server Client API REST API overview ----------------- -localhost:5000 +localhost:52425 Get the version of NEST used by NEST Server -localhost:5000/api +localhost:52425/api List all available functions -localhost:5000/api/ +localhost:52425/api/ Execute the function `` -localhost:5000/api/?inspect=getdoc +localhost:52425/api/?inspect=getdoc Get the documentation for the function `` -localhost:5000/api/?inspect=getsource +localhost:52425/api/?inspect=getsource Get the source code of the function `` -localhost:5000/exec +localhost:52425/exec Execute a Python script. This requires JSON data in the form .. code-block:: JSON @@ -330,7 +330,7 @@ website `_. To obtain basic information about the running server, run:: - curl localhost:5000 + curl localhost:52425 NEST Server responds to this by sending data in JSON format:: @@ -338,15 +338,15 @@ NEST Server responds to this by sending data in JSON format:: You can retrieve data about the callable functions of NEST by running:: - curl localhost:5000/api + curl localhost:52425/api Retrieve the current kernel status dict from NEST:: - curl localhost:5000/api/GetKernelStatus + curl localhost:52425/api/GetKernelStatus Send API request with function arguments in JSON format:: - curl -H "Content-Type: application/json" -d '{"model": "iaf_psc_alpha"}' localhost:5000/api/GetDefaults + curl -H "Content-Type: application/json" -d '{"model": "iaf_psc_alpha"}' localhost:52425/api/GetDefaults .. note:: @@ -354,7 +354,7 @@ Send API request with function arguments in JSON format:: ``curl`` through the JSON processor ``jq``. A sample command line to display the available functions in this way looks like this:: - curl -s localhost:5000/api | jq -r . + curl -s localhost:52425/api | jq -r . For more information, check the `documentation on jq `_. @@ -373,23 +373,23 @@ Sending a simple request to the NEST Server using Python works as follows:: import requests - requests.get('http://localhost:5000').json() + requests.get('http://localhost:52425').json() To display a list of callable functions, use:: - requests.get('http://localhost:5000/api').json() + requests.get('http://localhost:52425/api').json() Reset the NEST simulation kernel (no response):: - requests.get('http://localhost:5000/api/ResetKernel').json() + requests.get('http://localhost:52425/api/ResetKernel').json() Sending an API request in JSON format:: - requests.post('http://localhost:5000/api/GetDefaults', json={'model': 'iaf_psc_alpha'}).json() + requests.post('http://localhost:52425/api/GetDefaults', json={'model': 'iaf_psc_alpha'}).json() Create neurons in NEST and return a list of IDs for the new nodes:: - neurons = requests.post('http://localhost:5000/api/Create', json={"model": "iaf_psc_alpha", "n": 100}).json() + neurons = requests.post('http://localhost:52425/api/Create', json={"model": "iaf_psc_alpha", "n": 100}).json() print(neurons) .. _nest_server_security: @@ -463,7 +463,7 @@ Run scripts in NEST Server using `curl` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ As shown above, you can send custom simulation code to -``localhost:5000/exec``. On the command line, this approach might be a +``localhost:52425/exec``. On the command line, this approach might be a bit more challenging in the case your script does not fit on a single line. For such situations, we recommend using a JSON file as input for ``curl``: @@ -481,7 +481,7 @@ command: .. code-block:: sh - curl -H "Content-Type: application/json" -d @simulation_script.json http://localhost:5000/exec + curl -H "Content-Type: application/json" -d @simulation_script.json http://localhost:52425/exec Interact with NEST Server using JavaScript @@ -508,7 +508,7 @@ box. Here is a small example showing the basic idea: