namespace alps {
template<typename T> class AbstractSimpleObservable;
class ALPS_TEMPL_DECL SimpleObservableEvaluator;
template<typename T> bool error_underflow(T mean, T error);
template<typename T>
bool error_underflow(std::complex< T > mean, std::complex< T > error);
}
namespace alps {
enum error_convergence { CONVERGED, MAYBE_CONVERGED, NOT_CONVERGED };
std::string convergence_to_text(int c);
}
namespace alps {
template<typename T = double> class BasicDetailedBinning;
template<typename T> class DetailedBinning;
template<typename T> class FixedBinning;
typedef SimpleObservable< int32_t, DetailedBinning< int32_t > > IntObservable;
typedef SimpleObservable< double, DetailedBinning< double > > RealObservable;
typedef SimpleObservable< float, DetailedBinning< float > > FloatObservable;
typedef SimpleObservable< std::complex< double >, DetailedBinning< std::complex< double > > > ComplexObservable;
typedef SimpleObservable< double, FixedBinning< double > > RealTimeSeriesObservable;
typedef SimpleObservable< int32_t, FixedBinning< int32_t > > IntTimeSeriesObservable;
typedef SimpleObservable< std::valarray< int32_t >, DetailedBinning< std::valarray< int32_t > > > IntVectorObservable;
typedef SimpleObservable< std::valarray< double >, DetailedBinning< std::valarray< double > > > RealVectorObservable;
typedef SimpleObservable< std::valarray< float >, DetailedBinning< std::valarray< float > > > FloatVectorObservable;
typedef SimpleObservable< std::valarray< int32_t >, FixedBinning< std::valarray< int32_t > > > IntVectorTimeSeriesObservable;
typedef SimpleObservable< std::valarray< double >, FixedBinning< std::valarray< double > > > RealVectorTimeSeriesObservable;
}
ALPS_ALEA_IMPL_DISTANCE_LIMIT_FUNCTION(name)
ALPS_ALEA_IMPL_FROM_TO_MIN_MAX_FUNCTION(name)
ALPS_MCANALYZE_IMPLEMENT_OSTREAM(timeseries_type)
namespace alps {
namespace alea {
class None_class;
template<typename T> struct const_iterator_type;
template<typename ValueType>
struct const_iterator_type<alps::alea::mcdata< ValueType >>;
template<typename T> struct iterator_type;
template<typename ValueType>
struct iterator_type<alps::alea::mcdata< ValueType >>;
template<typename ValueType> class mctimeseries;
template<typename ValueType> class mctimeseries_view;
class NotEnoughMeasurementsError;
struct uncorrelated_selector;
struct binning_selector;
class alps::alea::None_class None;
struct alps::alea::uncorrelated_selector uncorrelated;
struct alps::alea::binning_selector binning;
template<typename TimeseriesType>
const_iterator_type< TimeseriesType >::type
range_begin(const TimeseriesType & timeseries);
template<typename ValueType>
std::vector< ValueType >::const_iterator
range_begin(const alps::alea::mcdata< ValueType > & timeseries);
template<typename TimeseriesType>
const_iterator_type< TimeseriesType >::type
range_end(const TimeseriesType & timeseries);
template<typename ValueType>
std::vector< ValueType >::const_iterator
range_end(const alps::alea::mcdata< ValueType > & timeseries);
template<typename TimeseriesType>
mctimeseries_view< typename TimeseriesType::value_type >
cut_head_distance(const TimeseriesType & timeseries, int cutoff);
template<typename TimeseriesType>
mctimeseries_view< typename TimeseriesType::value_type >
cut_tail_distance(const TimeseriesType & timeseries, int cutoff);
template<typename TimeseriesType>
mctimeseries_view< typename TimeseriesType::value_type >
cut_head_limit(const TimeseriesType & timeseries, double limit);
template<typename TimeseriesType>
mctimeseries_view< typename TimeseriesType::value_type >
cut_tail_limit(const TimeseriesType & timeseries, double limit);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
mean(const TimeseriesType & timeseries);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
variance(const TimeseriesType & timeseries);
template<typename TimeseriesType>
mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >
autocorrelation_distance(const TimeseriesType & timeseries, int up_to);
template<typename TimeseriesType>
mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >
autocorrelation_limit(const TimeseriesType & timeseries, double limit);
template<typename TimeseriesType>
std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type >
exponential_autocorrelation_time_distance(const TimeseriesType & autocorrelation,
int from, int to);
template<typename TimeseriesType>
std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type >
exponential_autocorrelation_time_limit(const TimeseriesType & autocorrelation,
double max, double min);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
integrated_autocorrelation_time(const TimeseriesType & autocorrelation,
const std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type > & tau);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
error(const TimeseriesType & timeseries,
const uncorrelated_selector & selector = alps::alea::uncorrelated);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
error(const TimeseriesType & timeseries,
const binning_selector & selector);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
uncorrelated_error(const TimeseriesType & timeseries);
template<typename TimeseriesType>
average_type< typename TimeseriesType::value_type >::type
binning_error(const TimeseriesType & timeseries);
template<typename TimeseriesType>
mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >
running_mean(const TimeseriesType & timeseries);
template<typename TimeseriesType>
mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >
reverse_running_mean(const TimeseriesType & timeseries);
}
}
namespace alps {
namespace alea {
template<typename T> class mcdata;
template<typename T>
std::ostream & operator<<(std::ostream & out, mcdata< T > const & obs);
ALPS_ALEA_MCDATA_IMPLEMENT_OPERATION(operator+, +);
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(atan,
abs(1./(1.+rhs.mean()*rhs.mean())*rhs.error()));
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(abs, rhs. error);
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sq, abs(2.*rhs.mean()*rhs.error()));
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cb,
abs(3.*sq(rhs.mean())*rhs.error()));
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sqrt,
abs(rhs.error()/(2.*sqrt(rhs.mean()))));
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cbrt,
abs(rhs.error()/(3.*sq(pow(rhs.mean(), 1./3)))));
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(exp, exp(rhs.mean())*rhs.error());
ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(log, abs(rhs.error()/rhs.mean()));
}
}
namespace alps {
ALPS_DECL double nan();
ALPS_DECL double inf();
ALPS_DECL double ninf();
}
namespace alps {
template<typename T = double, typename SIGN = double>
class RecordableObservable;
}
namespace alps {
template<typename OBS, typename SIGN = double>
class AbstractSignedObservable;
class A;
template<typename OBS, typename SIGN = double> class SignedObservable;
template<typename OBS>
boost::shared_ptr< Observable >
make_observable(const OBS & obs, bool issigned = false);
template<typename OBS, typename SIGN>
boost::shared_ptr< Observable >
make_observable(const OBS & obs, const std::string & s, SIGN,
bool issigned = true);
}
namespace alps {
template<typename T = double> class SimpleBinning;
}
namespace alps {
template<typename T> class SimpleObservableData;
double text_to_double(const std::string & val);
}
template<typename T>
std::ostream & operator<<(std::ostream & o, const std::valarray< T > &);
namespace alps {
template<typename T, typename BINNING> class SimpleObservable;
template<typename T, typename BINNING>
hdf5::archive &
operator<<(hdf5::archive & ar, SimpleObservable< T, BINNING > const & obs);
template<typename T, typename BINNING>
hdf5::archive &
operator>>(hdf5::archive & ar, SimpleObservable< T, BINNING > & obs);
}
OBSERVABLE_FUNCTION(F)
namespace alps {
struct ObservableNamingHelper;
template<typename T> class SimpleObservableEvaluator;
typedef SimpleObservableEvaluator< double > RealObsevaluator;
typedef SimpleObservableEvaluator< int32_t > IntObsevaluator;
typedef SimpleObservableEvaluator< std::complex< double > > ComplexObsevaluator;
typedef SimpleObservableEvaluator< std::valarray< int32_t > > IntVectorObsevaluator;
typedef SimpleObservableEvaluator< std::valarray< double > > RealVectorObsevaluator;
template<typename T, typename U>
alps::SimpleObservableEvaluator< T >
operator+(alps::SimpleObservableEvaluator< T > const & x,
const alps::SimpleObservableEvaluator< U > & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator+(alps::SimpleObservableEvaluator< T > const & x, const Y & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator+(const Y & y, alps::SimpleObservableEvaluator< T > const & x);
template<typename T, typename U>
alps::SimpleObservableEvaluator< T >
operator-(const alps::SimpleObservableEvaluator< T > & x,
const alps::SimpleObservableEvaluator< U > & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator-(alps::SimpleObservableEvaluator< T > const & x, const Y & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator-(const Y & y, alps::SimpleObservableEvaluator< T > const & x);
template<typename T, typename U>
alps::SimpleObservableEvaluator< T >
operator*(const alps::SimpleObservableEvaluator< T > & x,
const alps::SimpleObservableEvaluator< U > & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator*(alps::SimpleObservableEvaluator< T > const & x, const Y & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator*(const Y & y, alps::SimpleObservableEvaluator< T > const & x);
template<typename T>
alps::SimpleObservableEvaluator< std::valarray< T > >
operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x,
const alps::SimpleObservableEvaluator< T > & y);
template<typename T>
alps::SimpleObservableEvaluator< std::valarray< T > >
operator*(const alps::SimpleObservableEvaluator< T > & y,
alps::SimpleObservableEvaluator< std::valarray< T > > const & x);
template<typename T, typename U>
alps::SimpleObservableEvaluator< T >
operator/(const alps::SimpleObservableEvaluator< T > & x,
const alps::SimpleObservableEvaluator< U > & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator/(alps::SimpleObservableEvaluator< T > const & x, const Y & y);
template<typename T, typename Y>
alps::SimpleObservableEvaluator< T >
operator/(const Y & x, alps::SimpleObservableEvaluator< T > const & y);
template<typename T>
alps::SimpleObservableEvaluator< T >
pow(const alps::SimpleObservableEvaluator< T > & x, double p);
template<typename T>
alps::SimpleObservableEvaluator< T >
pow(const alps::SimpleObservableEvaluator< T > & x, int p);
}
IMPLEMENT_OPERATION(OPERATOR_NAME, OPERATOR_ASSIGN)
IMPLEMENT_OPERATION2(OPERATOR_NAME, OPERATOR_ASSIGN)
IMPLEMENT_VECTOR_OF_VALUE_WITH_ERROR_FUNCTION(NAME1, NAME2)
namespace alps {
namespace alea {
template<typename T> class value_with_error;
template<typename T>
std::ostream &
operator<<(std::ostream & out, value_with_error< T > const & value);
template<typename T>
std::ostream &
operator<<(std::ostream & out,
value_with_error< std::vector< T > > const & vec);
template<typename T>
value_with_error< T > & operator+(value_with_error< T > & rhs);
template<typename T>
value_with_error< T > operator-(value_with_error< T > rhs);
template<typename T> value_with_error< T > abs(value_with_error< T > rhs);
template<typename T>
value_with_error< T >
operator+(T const & lhs, value_with_error< T > rhs);
template<typename T>
value_with_error< T >
operator-(T const & lhs, value_with_error< T > rhs);
template<typename T>
value_with_error< T >
operator*(T const & lhs, value_with_error< T > rhs);
template<typename T>
value_with_error< T >
operator/(T const & lhs, value_with_error< T > const & rhs);
template<typename T>
value_with_error< T >
pow(value_with_error< T > rhs,
typename value_with_error< T >::element_type const & exponent);
template<typename T> value_with_error< T > sq(value_with_error< T > rhs);
template<typename T> value_with_error< T > cb(value_with_error< T > rhs);
template<typename T> value_with_error< T > sqrt(value_with_error< T > rhs);
template<typename T> value_with_error< T > cbrt(value_with_error< T > rhs);
template<typename T> value_with_error< T > exp(value_with_error< T > rhs);
template<typename T> value_with_error< T > log(value_with_error< T > rhs);
template<typename T> value_with_error< T > sin(value_with_error< T > rhs);
template<typename T> value_with_error< T > cos(value_with_error< T > rhs);
template<typename T> value_with_error< T > tan(value_with_error< T > rhs);
template<typename T> value_with_error< T > sinh(value_with_error< T > rhs);
template<typename T> value_with_error< T > cosh(value_with_error< T > rhs);
template<typename T> value_with_error< T > tanh(value_with_error< T > rhs);
template<typename T> value_with_error< T > asin(value_with_error< T > rhs);
template<typename T> value_with_error< T > acos(value_with_error< T > rhs);
template<typename T> value_with_error< T > atan(value_with_error< T > rhs);
template<typename T>
value_with_error< T > asinh(value_with_error< T > rhs);
template<typename T>
value_with_error< T > acosh(value_with_error< T > rhs);
template<typename T>
value_with_error< T > atanh(value_with_error< T > rhs);
template<typename T>
std::vector< value_with_error< T > >
operator+(std::vector< value_with_error< T > > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator+(std::vector< value_with_error< T > > const & lhs,
T const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator+(T const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator+(std::vector< value_with_error< T > > const & lhs,
std::vector< T > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator+(std::vector< T > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator-(std::vector< value_with_error< T > > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator-(std::vector< value_with_error< T > > const & lhs,
T const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator-(T const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator-(std::vector< value_with_error< T > > const & lhs,
std::vector< T > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator-(std::vector< T > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator*(std::vector< value_with_error< T > > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator*(std::vector< value_with_error< T > > const & lhs,
T const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator*(T const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator*(std::vector< value_with_error< T > > const & lhs,
std::vector< T > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator*(std::vector< T > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator/(std::vector< value_with_error< T > > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator/(std::vector< value_with_error< T > > const & lhs,
T const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator/(T const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator/(std::vector< value_with_error< T > > const & lhs,
std::vector< T > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
operator/(std::vector< T > const & lhs,
std::vector< value_with_error< T > > const & rhs);
template<typename T>
std::vector< T > operator-(std::vector< T > const & rhs);
template<typename T>
std::vector< value_with_error< T > >
vec_pow(std::vector< value_with_error< T > > const & rhs,
T const & exponent);
template<typename T>
std::vector< value_with_error< T > >
obtain_vector_of_value_with_error_from_vector_with_error(value_with_error< std::vector< T > > vec_with_error);
template<typename T>
value_with_error< std::vector< T > >
obtain_vector_with_error_from_vector_of_value_with_error(std::vector< value_with_error< T > > vec_of_value_with_error);
}
}