max_num_binning.hpp File Reference

#include <alps/config.hpp>
#include <alps/accumulators/feature.hpp>
#include <alps/accumulators/parameter.hpp>
#include <alps/accumulators/feature/mean.hpp>
#include <alps/accumulators/feature/count.hpp>
#include <alps/accumulators/feature/error.hpp>
#include <alps/numeric/inf.hpp>
#include <alps/numeric/boost_array_functions.hpp>
#include <alps/numeric/check_size.hpp>
#include <alps/numeric/vector_functions.hpp>
#include <alps/hdf5/archive.hpp>
#include <alps/utilities/stacktrace.hpp>
#include <alps/utilities/short_print.hpp>
#include <alps/numeric/outer_product.hpp>
#include <alps/type_traits/covariance_type.hpp>
#include <boost/utility.hpp>
#include <boost/function.hpp>
#include <stdexcept>
#include <type_traits>

Include dependency graph for max_num_binning.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	alps::accumulators::max_num_binning_type< T >
struct	alps::accumulators::has_feature< T, max_num_binning_tag >
struct	alps::accumulators::covariance_type< T >
struct	alps::accumulators::impl::Accumulator< T, max_num_binning_tag, B >
class	alps::accumulators::impl::Result< T, max_num_binning_tag, B >
class	alps::accumulators::impl::BaseWrapper< T, max_num_binning_tag, B >
class	alps::accumulators::impl::DerivedWrapper< T, max_num_binning_tag, B >

Namespaces
	alps
	alps::accumulators
	alps::accumulators::impl

Macros
#define	NUMERIC_FUNCTION_OPERATOR(OP_NAME, OPEQ_NAME, OP, OP_TOKEN, OP_STD)

Functions
template<typename T >
max_num_binning_type< T >::type	alps::accumulators::max_num_binning (T const &arg)

Macro Definition Documentation

#define NUMERIC_FUNCTION_OPERATOR	(		OP_NAME,
			OPEQ_NAME,
			OP,
			OP_TOKEN,
			OP_STD
	)

Value:

template<typename U> void aug ## OP_TOKEN (U const & arg, typename std::enable_if<!std::is_scalar<U>::value, int>::type = 0) { \
                    typedef typename value_type<B>::type self_value_type; \
                    typedef typename value_type<U>::type arg_value_type; \
                    transform(boost::function<self_value_type(self_value_type, arg_value_type)>( OP_STD <self_value_type, arg_value_type, self_value_type>()), arg); \
                    B:: OPEQ_NAME (arg);                                \
                }                                                       \
                template<typename U> void aug ## OP_TOKEN (U const & arg, typename std::enable_if<std::is_scalar<U>::value, int>::type = 0) { \
                    using alps::numeric:: OP_NAME ;                     \
                    typedef typename mean_type<B>::type mean_type;      \
                    generate_jackknife();                               \
                    m_mn_data_is_analyzed = false;                      \
                    m_mn_cannot_rebin = true;                           \
                    typename std::vector<mean_type>::iterator it;       \
                    for (it = m_mn_bins.begin(); it != m_mn_bins.end(); ++it) \
                        *it = *it OP static_cast<typename alps::numeric::scalar<mean_type>::type>(arg); \
                    for (it = m_mn_jackknife_bins.begin(); it != m_mn_jackknife_bins.end(); ++it) \
                        *it = *it OP static_cast<typename alps::numeric::scalar<mean_type>::type>(arg); \
                    analyze();                                          \
                    B:: OPEQ_NAME (arg);                                \
                }                                                       \

Definition at line 400 of file max_num_binning.hpp.