Reference

Summary

Members	Descriptions
`namespace` `alps`
`namespace` `alps::alea`
`namespace` `alps::detail`
`class` `alps::alea::mcdata::const_iterator`

namespace `alps`

Summary

Members	Descriptions
`enum` `error_convergence`
`enum` `Target`
`public template<>` `inline bool` `error_underflow(T mean,T error)`
`public template<>` `inline bool` `error_underflow(std::complex< T > mean,std::complex< T > error)`
`public template<>` `inline std::string` `convergence_to_text(T)`
`public inline std::string` `convergence_to_text(int c)`
`public double` `nan()`
`public double` `inf()`
`public double` `ninf()`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::Observable` `& m)`	write an observable to a std::ostream
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::ObservableSet` `& obs)`	output all observables in an ObservableSet
`public template<>` `boost::shared_ptr<` `Observable>make_observable(const OBS & obs,bool issigned)`
`public template<>` `boost::shared_ptr<` `Observable>make_observable(const OBS & obs,const std::string & s,SIGN,bool issigned)`
`public inline double` `text_to_double(const std::string & val)`
`public template<>` `hdf5::archive &` `operator<<(hdf5::archive & ar,SimpleObservable< T, BINNING > const & obs)`
`public template<>` `hdf5::archive &` `operator>>(hdf5::archive & ar,SimpleObservable< T, BINNING > & obs)`
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const` `alps::SimpleObservableEvaluator< U > & y)`	sum of two observables
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`	sum of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator+(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`	sum of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator-(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`	difference of two observables (IBM AIX workaround)
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator-(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`	difference of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator-(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`	difference of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator*(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`	product of two observables (IBM AIX workaround)
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator*(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`	product of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator*(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`	product of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x,const` `alps::SimpleObservableEvaluator< T > & y)`	product of vector and scalar observable
`public template<>` `inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(const` `alps::SimpleObservableEvaluator< T > & y,alps::SimpleObservableEvaluator< std::valarray< T > > const & x)`	product of vector and scalar observable
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator/(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`	ratio of two observables (IBM AIX workaround)
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator/(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`	ratio of observable and number
`public template<>` `inline` `alps::SimpleObservableEvaluator< T >` `operator/(const Y & x,alps::SimpleObservableEvaluator< T > const & y)`	ratio of number and observable
`public template<>` `alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,double p)`
`public template<>` `alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,int p)`
`class` `alps::A`
`class` `alps::AbstractBinning`
`class` `alps::AbstractSignedObservable`
`class` `alps::AbstractSimpleObservable`
`class` `alps::BasicDetailedBinning`
`class` `alps::DetailedBinning`
`class` `alps::FixedBinning`
`class` `alps::HistogramObservable`
`class` `alps::HistogramObservableData`
`class` `alps::HistogramObservableEvaluator`
`class` `alps::NoBinning`
`class` `alps::NoMeasurementsError`	an error class if no measurement was performed
`class` `alps::Observable`	the base class for all observables
`class` `alps::ObservableFactory`	A class to collect the various measurements performed in a simulation It is implemented as a map, with std::string as key type
`class` `alps::ObservableSet`
`class` `alps::ObservableSetXMLHandler`	XML parser for the ObservableSet class.
`class` `alps::ObsValueXMLHandler`
`class` `alps::RealHistogramEntryXMLHandler`	XML parser for the entries for RealHistogramObservable class.
`class` `alps::RealHistogramObservableXMLHandler`	XML parser for the RealHistogramObservable class.
`class` `alps::RealObsevaluatorValueXMLHandler`	XML parser for the elements for RealObsevaluator class.
`class` `alps::RealObsevaluatorXMLHandler`	XML parser for the RealObsevaluator class.
`class` `alps::RealVectorObsevaluatorXMLHandler`	XML parser for the RealVectorObsevaluator class.
`class` `alps::RecordableObservable`
`class` `alps::SignedObservable`
`class` `alps::SimpleBinning`
`class` `alps::SimpleObservable`
`class` `alps::SimpleObservableData`
`class` `alps::SimpleObservableEvaluator`
`struct` `alps::ObservableNamingHelper`
`struct` `alps::output_helper`
`struct` `alps::output_helper< boost::mpl::false_ >`
`struct` `alps::output_helper< boost::mpl::true_ >`
`struct` `alps::type_tag< std::valarray< T > >`
`struct` `alps::type_tag< std::vector< T > >`

Members

`enum` `error_convergence`

Values	Descriptions
CONVERGED
MAYBE_CONVERGED
NOT_CONVERGED

`enum` `Target`

Values	Descriptions
Mean
Error
Variance
Tau

`public template<>`
`inline bool` `error_underflow(T mean,T error)`

`public template<>`
`inline bool` `error_underflow(std::complex< T > mean,std::complex< T > error)`

`public template<>`
`inline std::string` `convergence_to_text(T)`

`public inline std::string` `convergence_to_text(int c)`

`public double` `nan()`

`public double` `inf()`

`public double` `ninf()`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::Observable` `& m)`

write an observable to a std::ostream

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::ObservableSet` `& obs)`

output all observables in an ObservableSet

`public template<>`
`boost::shared_ptr<` `Observable>make_observable(const OBS & obs,bool issigned)`

`public template<>`
`boost::shared_ptr<` `Observable>make_observable(const OBS & obs,const std::string & s,SIGN,bool issigned)`

`public inline double` `text_to_double(const std::string & val)`

`public template<>`
`hdf5::archive &` `operator<<(hdf5::archive & ar,SimpleObservable< T, BINNING > const & obs)`

`public template<>`
`hdf5::archive &` `operator>>(hdf5::archive & ar,SimpleObservable< T, BINNING > & obs)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const` `alps::SimpleObservableEvaluator & y)`

sum of two observables

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

sum of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

sum of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator & y)`

difference of two observables (IBM AIX workaround)

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

difference of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

difference of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator & y)`

product of two observables (IBM AIX workaround)

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

product of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

product of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x,const` `alps::SimpleObservableEvaluator< T > & y)`

product of vector and scalar observable

`public template<>`
`inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(const` `alps::SimpleObservableEvaluator< T > & y,alps::SimpleObservableEvaluator< std::valarray< T > > const & x)`

product of vector and scalar observable

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator & y)`

ratio of two observables (IBM AIX workaround)

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

ratio of observable and number

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(const Y & x,alps::SimpleObservableEvaluator< T > const & y)`

ratio of number and observable

`public template<>`
`alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,double p)`

`public template<>`
`alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,int p)`

class `alps::A`

Summary

Members	Descriptions

Members

class `alps::AbstractBinning`

Summary

Members	Descriptions
`public inline` `AbstractBinning(std::size_t)`
`public inline time_type` `tau() const`
`public inline uint32_t` `max_bin_number() const`
`public inline uint32_t` `bin_number() const`
`public inline uint32_t` `filled_bin_number() const`
`public inline uint32_t` `filled_bin_number2() const`
`public inline uint32_t` `bin_size() const`
`public inline const value_type &` `bin_value(uint32_t) const`
`public inline const value_type &` `bin_value2(uint32_t) const`
`public inline const std::vector< value_type > &` `bins() const`
`public inline void` `extract_timeseries(ODump & dump) const`
`public inline bool` `has_variance() const`
`public inline void` `write_scalar_xml(oxstream &) const`
`public template<>` `inline void` `write_vector_xml(oxstream &,IT) const`
`public inline void` `save(ODump &) const`
`public inline void` `load(IDump & dump)`
`public inline void` `save(hdf5::archive &) const`
`public inline void` `load(hdf5::archive &)`
`public inline std::string` `evaluation_method() const`
`typedef` `value_type`
`typedef` `time_type`
`typedef` `convergence_type`

Members

`public inline` `AbstractBinning(std::size_t)`

`public inline time_type` `tau() const`

`public inline uint32_t` `max_bin_number() const`

`public inline uint32_t` `bin_number() const`

`public inline uint32_t` `filled_bin_number() const`

`public inline uint32_t` `filled_bin_number2() const`

`public inline uint32_t` `bin_size() const`

`public inline const value_type &` `bin_value(uint32_t) const`

`public inline const value_type &` `bin_value2(uint32_t) const`

`public inline const std::vector< value_type > &` `bins() const`

`public inline void` `extract_timeseries(ODump & dump) const`

`public inline bool` `has_variance() const`

`public inline void` `write_scalar_xml(oxstream &) const`

`public template<>`
`inline void` `write_vector_xml(oxstream &,IT) const`

`public inline void` `save(ODump &) const`

`public inline void` `load(IDump & dump)`

`public inline void` `save(hdf5::archive &) const`

`public inline void` `load(hdf5::archive &)`

`public inline std::string` `evaluation_method() const`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `convergence_type`

class `alps::AbstractSignedObservable`

class alps::AbstractSignedObservable
  : public alps::AbstractSimpleObservable< OBS::value_type >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(int,version)`
`public inline` `AbstractSignedObservable(const OBS & obs,const std::string & s)`
`public inline` `AbstractSignedObservable(const std::string & name,const std::string & s,const label_type & l)`
`public inline` `AbstractSignedObservable(const std::string & name,const char * s,const label_type & l)`
`public template<>` `inline` `AbstractSignedObservable(const` `AbstractSignedObservable< OBS2, SIGN > & o)`
`public template<>` `inline` `AbstractSignedObservable(const std::string & name,const ARG & arg,const label_type & l)`
`public template<>` `inline` `AbstractSignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)`
`public inline` `~AbstractSignedObservable()`
`public inline virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public inline virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`	output the result
`public void` `output_scalar(std::ostream &) const`
`public void` `output_vector(std::ostream &) const`
`public inline virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`	output the result
`public inline virtual count_type` `count() const`	the number of measurements
`public inline virtual result_type` `mean() const`	the mean value
`public inline virtual result_type` `error() const`	the error
`public inline virtual convergence_type` `converged_errors() const`
`public inline virtual` `SimpleObservableEvaluator< value_type >` `make_evaluator() const`
`public template<>` `inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `slice(S s,const std::string & newname) const`
`public template<>` `inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `operator[](S s) const`
`public virtual void` `save(ODump & dump) const`
`public virtual void` `load(IDump & dump)`
`public virtual void` `save(hdf5::archive &) const`
`public virtual void` `load(hdf5::archive &)`
`public inline virtual` `Observable*clone() const`	clones the observable
`public inline virtual bool` `is_signed() const`	is the observable signed?
`public inline virtual void` `set_sign_name(const std::string & signname)`	set the name of the observable containing the sign for this observable
`public virtual void` `set_sign(const` `Observable` `& sign)`	set the observable containing the sign
`public inline virtual void` `clear_sign()`	clear any previosuly set sign observable
`public virtual const` `Observable&sign() const`	get a reference to the sign observable
`public inline virtual const std::string` `sign_name() const`	get the name of the observable containing the sign
`public inline virtual const` `Observable&signed_observable() const`
`public inline virtual uint32_t` `number_of_runs() const`	get the number of runs which performed measurements for this observable
`public virtual` `Observable*get_run(uint32_t) const`	extract an observable from a specific run only
`protected observable_type` `obs_`
`protected std::string` `sign_name_`
`protected const` `Observable*sign_`
`protected inline virtual` `Observable*convert_mergeable() const`	create a copy of the observable that can be merged
`protected virtual void` `write_more_xml(oxstream & oxs,slice_index it) const`
`protected inline virtual void` `merge(const` `Observable` `& o)`
`protected inline virtual bool` `can_merge() const`	can this observable be merged with one of the same type
`protected inline virtual bool` `can_merge(const` `Observable` `&) const`	can this observable be merged with one of the given type
`typedef` `observable_type`
`typedef` `sign_type`
`typedef` `value_type`
`typedef` `result_type`
`typedef` `base_type`
`typedef` `slice_index`
`typedef` `count_type`
`typedef` `time_type`
`typedef` `convergence_type`
`typedef` `label_type`

Members

`public` `BOOST_STATIC_CONSTANT(int,version)`

`public inline` `AbstractSignedObservable(const OBS & obs,const std::string & s)`

`public inline` `AbstractSignedObservable(const std::string & name,const std::string & s,const label_type & l)`

`public inline` `AbstractSignedObservable(const std::string & name,const char * s,const label_type & l)`

`public template<>`
`inline` `AbstractSignedObservable(const` `AbstractSignedObservable< OBS2, SIGN > & o)`

`public template<>`
`inline` `AbstractSignedObservable(const std::string & name,const ARG & arg,const label_type & l)`

`public template<>`
`inline` `AbstractSignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)`

`public inline` `~AbstractSignedObservable()`

`public inline virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public inline virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

output the result

`public void` `output_scalar(std::ostream &) const`

`public void` `output_vector(std::ostream &) const`

`public inline virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`

output the result

`public inline virtual count_type` `count() const`

the number of measurements

`public inline virtual result_type` `mean() const`

the mean value

`public inline virtual result_type` `error() const`

the error

`public inline virtual convergence_type` `converged_errors() const`

`public inline virtual` `SimpleObservableEvaluator< value_type >` `make_evaluator() const`

`public template<>`
`inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `slice(S s,const std::string & newname) const`

`public template<>`
`inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `operator[](S s) const`

`public virtual void` `save(ODump & dump) const`

`public virtual void` `load(IDump & dump)`

`public virtual void` `save(hdf5::archive &) const`

`public virtual void` `load(hdf5::archive &)`

`public inline virtual` `Observable*clone() const`

clones the observable

`public inline virtual bool` `is_signed() const`

is the observable signed?

`public inline virtual void` `set_sign_name(const std::string & signname)`

set the name of the observable containing the sign for this observable

`public virtual void` `set_sign(const` `Observable` `& sign)`

set the observable containing the sign

`public inline virtual void` `clear_sign()`

clear any previosuly set sign observable

`public virtual const` `Observable&sign() const`

get a reference to the sign observable

`public inline virtual const std::string` `sign_name() const`

get the name of the observable containing the sign

`public inline virtual const` `Observable&signed_observable() const`

`public inline virtual uint32_t` `number_of_runs() const`

get the number of runs which performed measurements for this observable

`public virtual` `Observable*get_run(uint32_t) const`

extract an observable from a specific run only

`protected observable_type` `obs_`

`protected std::string` `sign_name_`

`protected const` `Observable*sign_`

`protected inline virtual` `Observable*convert_mergeable() const`

create a copy of the observable that can be merged

`protected virtual void` `write_more_xml(oxstream & oxs,slice_index it) const`

`protected inline virtual void` `merge(const` `Observable` `& o)`

`protected inline virtual bool` `can_merge() const`

can this observable be merged with one of the same type

`protected inline virtual bool` `can_merge(const` `Observable` `&) const`

can this observable be merged with one of the given type

`typedef` `observable_type`

`typedef` `sign_type`

`typedef` `value_type`

`typedef` `result_type`

`typedef` `base_type`

`typedef` `slice_index`

`typedef` `count_type`

`typedef` `time_type`

`typedef` `convergence_type`

`typedef` `label_type`

class `alps::AbstractSimpleObservable`

class alps::AbstractSimpleObservable
  : public alps::Observable

Summary

Members	Descriptions
`public inline` `AbstractSimpleObservable(const std::string & name,const label_type & l)`
`public inline virtual` `~AbstractSimpleObservable()`
`public` `count_type` `count() const`	the number of measurements
`public` `result_type` `mean() const`	the mean value
`public inline virtual` `result_type` `variance() const`	the variance
`public` `result_type` `error() const`	the error
`public convergence_type` `converged_errors() const`
`public inline virtual bool` `has_minmax() const`	is information about the minimum and maximum value available?
`public inline virtual` `value_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const`	the minimum value
`public inline virtual` `value_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const`	the maximum value
`public inline virtual bool` `has_tau() const`	is autocorrelation information available ?
`public inline virtual` `time_type` `tau() const`	the autocorrelation time, throws an exception if not available
`public inline virtual bool` `has_variance() const`	is variance available ?
`public inline virtual` `count_type` `bin_number() const`	the number of bins
`public inline virtual` `count_type` `max_bin_number() const`	the number of bins
`public inline virtual` `count_type` `bin_size() const`	the number of measurements per bin
`public inline virtual const` `value_type&bin_value(count_type) const`	the value of a bin
`public inline virtual` `count_type` `bin_number2() const`	the number of bins with squared values
`public inline virtual const` `value_type&bin_value2(count_type) const`	the squared value of a bin
`public template<>` `inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(S s,const std::string & newname) const`	slice the data type using a single argument. This can easily be extended when needed to more data types.
`public template<>` `inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `operator[](S s) const`
`public void` `extract_timeseries(ODump & dump) const`
`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`	output the result
`public void` `write_xml_scalar(oxstream &,const boost::filesystem::path &) const`
`public void` `write_xml_vector(oxstream &,const boost::filesystem::path &) const`
`public inline virtual std::string` `evaluation_method(Target) const`
`public inline` `operator SimpleObservableEvaluator< value_type >() const`
`public inline void` `set_label(const label_type & l)`
`public inline const label_type &` `label() const`
`public inline virtual void` `save(ODump & dump) const`
`public inline virtual void` `load(IDump & dump)`
`public virtual void` `save(hdf5::archive &) const`
`public virtual void` `load(hdf5::archive &)`
`typedef` `value_type`	the data type of the observable
`typedef` `result_type`	the data type of averages and errors
`typedef` `slice_index`
`typedef` `count_type`	the count data type: an integral type
`typedef` `time_type`	the data type for autocorrelation times
`typedef` `convergence_type`
`typedef` `label_type`

Members

`public inline` `AbstractSimpleObservable(const std::string & name,const label_type & l)`

`public inline virtual` `~AbstractSimpleObservable()`

`public` `count_type` `count() const`

the number of measurements

`public` `result_type` `mean() const`

the mean value

`public inline virtual` `result_type` `variance() const`

the variance

`public` `result_type` `error() const`

the error

`public convergence_type` `converged_errors() const`

`public inline virtual bool` `has_minmax() const`

is information about the minimum and maximum value available?

`public inline virtual` `value_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const`

the minimum value

`public inline virtual` `value_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const`

the maximum value

`public inline virtual bool` `has_tau() const`

is autocorrelation information available ?

`public inline virtual` `time_type` `tau() const`

the autocorrelation time, throws an exception if not available

`public inline virtual bool` `has_variance() const`

is variance available ?

`public inline virtual` `count_type` `bin_number() const`

the number of bins

`public inline virtual` `count_type` `max_bin_number() const`

the number of bins

`public inline virtual` `count_type` `bin_size() const`

the number of measurements per bin

`public inline virtual const` `value_type&bin_value(count_type) const`

the value of a bin

`public inline virtual` `count_type` `bin_number2() const`

the number of bins with squared values

`public inline virtual const` `value_type&bin_value2(count_type) const`

the squared value of a bin

`public template<>`
`inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(S s,const std::string & newname) const`

slice the data type using a single argument. This can easily be extended when needed to more data types.

Parameters

s the slice
newname optionally a new name for the slice. Default is the same name as the original observable

`public template<>`
`inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `operator[](S s) const`

`public void` `extract_timeseries(ODump & dump) const`

`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`

output the result

`public void` `write_xml_scalar(oxstream &,const boost::filesystem::path &) const`

`public void` `write_xml_vector(oxstream &,const boost::filesystem::path &) const`

`public inline virtual std::string` `evaluation_method(Target) const`

`public inline` `operator SimpleObservableEvaluator< value_type >() const`

`public inline void` `set_label(const label_type & l)`

`public inline const label_type &` `label() const`

`public inline virtual void` `save(ODump & dump) const`

`public inline virtual void` `load(IDump & dump)`

`public virtual void` `save(hdf5::archive &) const`

`public virtual void` `load(hdf5::archive &)`

`typedef` `value_type`

the data type of the observable

`typedef` `result_type`

the data type of averages and errors

`typedef` `slice_index`

`typedef` `count_type`

the count data type: an integral type

`typedef` `time_type`

the data type for autocorrelation times

`typedef` `convergence_type`

`typedef` `label_type`

class `alps::BasicDetailedBinning`

class alps::BasicDetailedBinning
  : public alps::SimpleBinning< double >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`
`public` `BOOST_STATIC_CONSTANT(int,magic_id)`
`public inline` `BasicDetailedBinning(uint32_t binsize,uint32_t binnum)`
`public inline void` `reset(bool)`
`public inline void` `operator<<(const T & x)`
`public inline uint32_t` `max_bin_number() const`
`public inline uint32_t` `bin_number() const`
`public inline uint32_t` `filled_bin_number() const`
`public inline uint32_t` `filled_bin_number2() const`
`public void` `set_bin_number(uint32_t binnum)`
`public void` `collect_bins(uint32_t howmany)`
`public inline uint32_t` `bin_size() const`
`public void` `set_bin_size(uint32_t binsize)`
`public inline const value_type &` `bin_value(uint32_t i) const`
`public inline const value_type &` `bin_value2(uint32_t i) const`
`public inline const std::vector< value_type > &` `bins() const`
`public inline void` `compact()`
`public inline void` `save(ODump & dump) const`
`public inline void` `load(IDump & dump)`
`public inline void` `extract_timeseries(ODump & dump) const`
`public inline void` `save(hdf5::archive &) const`
`public inline void` `load(hdf5::archive &)`
`typedef` `value_type`
`typedef` `time_type`
`typedef` `size_type`
`typedef` `result_type`

Members

`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`

`public` `BOOST_STATIC_CONSTANT(int,magic_id)`

`public inline` `BasicDetailedBinning(uint32_t binsize,uint32_t binnum)`

`public inline void` `reset(bool)`

`public inline void` `operator<<(const T & x)`

`public inline uint32_t` `max_bin_number() const`

`public inline uint32_t` `bin_number() const`

`public inline uint32_t` `filled_bin_number() const`

`public inline uint32_t` `filled_bin_number2() const`

`public void` `set_bin_number(uint32_t binnum)`

`public void` `collect_bins(uint32_t howmany)`

`public inline uint32_t` `bin_size() const`

`public void` `set_bin_size(uint32_t binsize)`

`public inline const value_type &` `bin_value(uint32_t i) const`

`public inline const value_type &` `bin_value2(uint32_t i) const`

`public inline const std::vector< value_type > &` `bins() const`

`public inline void` `compact()`

`public inline void` `save(ODump & dump) const`

`public inline void` `load(IDump & dump)`

`public inline void` `extract_timeseries(ODump & dump) const`

`public inline void` `save(hdf5::archive &) const`

`public inline void` `load(hdf5::archive &)`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `size_type`

`typedef` `result_type`

class `alps::DetailedBinning`

class alps::DetailedBinning
  : public alps::BasicDetailedBinning< T >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(int,magic_id)`
`public inline` `DetailedBinning(uint32_t binnum,uint32_t)`
`typedef` `value_type`

Members

`public` `BOOST_STATIC_CONSTANT(int,magic_id)`

`public inline` `DetailedBinning(uint32_t binnum,uint32_t)`

`typedef` `value_type`

class `alps::FixedBinning`

class alps::FixedBinning
  : public alps::BasicDetailedBinning< T >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(int,magic_id)`
`public inline` `FixedBinning(uint32_t binsize,uint32_t)`
`typedef` `value_type`

Members

`public` `BOOST_STATIC_CONSTANT(int,magic_id)`

`public inline` `FixedBinning(uint32_t binsize,uint32_t)`

`typedef` `value_type`

class `alps::HistogramObservable`

class alps::HistogramObservable
  : public alps::Observable
  : public alps::RecordableObservable< T >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(uint32_t,version)`
`public` `HistogramObservable(const std::string & n)`
`public inline` `HistogramObservable(const std::string & n,T min,T max,T stepsize)`
`public inline void` `set_range(T min,T max,T stepsize)`
`public inline virtual` `Observable*clone() const`	clones the observable
`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public inline virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`	output the result
`public inline virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public inline virtual void` `save(ODump & dump) const`
`public inline virtual void` `load(IDump & dump)`
`public inline virtual void` `add(const T & x)`	add a simple T-value to the Observable
`public inline virtual void` `operator<<(const T & x)`	add a simple T-value to the Observable
`public inline const_iterator` `begin() const`
`public inline const_iterator` `rbegin() const`
`public inline const_iterator` `end() const`
`public inline const_iterator` `rend() const`
`public inline size_type` `size() const`
`public inline value_type` `operator[](size_type i) const`
`public inline value_type` `at(size_type i) const`
`public inline virtual bool` `can_merge() const`	can this observable be merged with one of the same type
`public inline virtual bool` `can_merge(const` `alps::Observable` `&) const`	can this observable be merged with one of the given type
`public inline value_type &` `operator[](size_type i)`
`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`	output the result
`public inline count_type` `count() const`
`public inline range_type` `stepsize() const`
`public inline range_type max` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline range_type min` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline` `operator HistogramObservableEvaluator< T >() const`
`public inline virtual void` `save(hdf5::archive &) const`
`public inline virtual void` `load(hdf5::archive &)`
`protected mutable std::vector< value_type >` `histogram_`
`protected mutable count_type` `count_`
`typedef` `value_type`
`typedef` `range_type`
`typedef` `count_type`
`typedef` `const_iterator`
`typedef` `const_reverse_iterator`
`typedef` `size_type`

Members

`public` `BOOST_STATIC_CONSTANT(uint32_t,version)`

`public` `HistogramObservable(const std::string & n)`

`public inline` `HistogramObservable(const std::string & n,T min,T max,T stepsize)`

`public inline void` `set_range(T min,T max,T stepsize)`

`public inline virtual` `Observable*clone() const`

clones the observable

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public inline virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

output the result

`public inline virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public inline virtual void` `save(ODump & dump) const`

`public inline virtual void` `load(IDump & dump)`

`public inline virtual void` `add(const T & x)`

add a simple T-value to the Observable

`public inline virtual void` `operator<<(const T & x)`

add a simple T-value to the Observable

`public inline const_iterator` `begin() const`

`public inline const_iterator` `rbegin() const`

`public inline const_iterator` `end() const`

`public inline const_iterator` `rend() const`

`public inline size_type` `size() const`

`public inline value_type` `operator[](size_type i) const`

`public inline value_type` `at(size_type i) const`

`public inline virtual bool` `can_merge() const`

can this observable be merged with one of the same type

`public inline virtual bool` `can_merge(const` `alps::Observable` `&) const`

can this observable be merged with one of the given type

`public inline value_type &` `operator[](size_type i)`

`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`

output the result

`public inline count_type` `count() const`

`public inline range_type` `stepsize() const`

`public inline range_type max` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline range_type min` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline` `operator HistogramObservableEvaluator< T >() const`

`public inline virtual void` `save(hdf5::archive &) const`

`public inline virtual void` `load(hdf5::archive &)`

`protected mutable std::vector< value_type >` `histogram_`

`protected mutable count_type` `count_`

`typedef` `value_type`

`typedef` `range_type`

`typedef` `count_type`

`typedef` `const_iterator`

`typedef` `const_reverse_iterator`

`typedef` `size_type`

class `alps::HistogramObservableData`

Summary

Members	Descriptions
`public inline` `HistogramObservableData()`
`public inline` `HistogramObservableData(const` `HistogramObservable< T > & obs)`
`public inline` `HistogramObservableData(std::istream & infile,const XMLTag & intag)`
`public inline size_type` `size() const`
`public inline void` `read_xml(std::istream & infile,const XMLTag & intag)`
`public inline void` `read_xml_histogram(std::istream & infile,const XMLTag & intag)`
`public inline count_type` `count() const`
`public size_type` `value(uint32_t) const`
`public inline range_type min` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline range_type max` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline range_type` `stepsize() const`
`public inline void` `save(ODump & dump) const`
`public inline void` `load(IDump & dump)`
`public inline void` `collect_from(const std::vector<` `HistogramObservableData< T > > & runs)`
`public inline value_type` `operator[](size_type i) const`
`typedef` `integer_type`
`typedef` `value_type`
`typedef` `size_type`
`typedef` `count_type`
`typedef` `range_type`

Members

`public inline` `HistogramObservableData()`

`public inline` `HistogramObservableData(const` `HistogramObservable< T > & obs)`

`public inline` `HistogramObservableData(std::istream & infile,const XMLTag & intag)`

`public inline size_type` `size() const`

`public inline void` `read_xml(std::istream & infile,const XMLTag & intag)`

`public inline void` `read_xml_histogram(std::istream & infile,const XMLTag & intag)`

`public inline count_type` `count() const`

`public size_type` `value(uint32_t) const`

`public inline range_type min` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline range_type max` `BOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline range_type` `stepsize() const`

`public inline void` `save(ODump & dump) const`

`public inline void` `load(IDump & dump)`

`public inline void` `collect_from(const std::vector<` `HistogramObservableData< T > > & runs)`

`public inline value_type` `operator[](size_type i) const`

`typedef` `integer_type`

`typedef` `value_type`

`typedef` `size_type`

`typedef` `count_type`

`typedef` `range_type`

class `alps::HistogramObservableEvaluator`

class alps::HistogramObservableEvaluator
  : public alps::HistogramObservable< T >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(uint32_t,version)`
`public inline` `HistogramObservableEvaluator(const std::string & n)`
`public inline` `HistogramObservableEvaluator(const char * n)`
`public inline` `HistogramObservableEvaluator(const` `HistogramObservableEvaluator` `& eval)`
`public inline` `HistogramObservableEvaluator(const` `Observable` `& obs,const std::string &)`
`public inline` `HistogramObservableEvaluator(const` `Observable` `&)`
`public inline` `HistogramObservableEvaluator(const std::string & n,std::istream &,const XMLTag &)`
`public inline virtual` `~HistogramObservableEvaluator()`
`public inline const` `HistogramObservableEvaluator< T > &` `operator=(const` `HistogramObservableEvaluator< T > & eval)`
`public inline const` `HistogramObservableEvaluator< T > &` `operator=(const` `HistogramObservable< T > & obs)`
`public inline` `HistogramObservableEvaluator< T > &` `operator<<(const` `HistogramObservable< T > & obs)`
`public inline virtual void` `rename(const std::string &)`	rename the observable
`public inline void` `rename(const std::string n,bool a)`
`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public inline value_type` `operator[](int i) const`
`public inline count_type` `count() const`
`public inline virtual` `Observable*clone() const`	clones the observable
`public inline virtual uint32_t` `number_of_runs() const`	get the number of runs which performed measurements for this observable
`public inline virtual` `Observable*get_run(uint32_t) const`	extract an observable from a specific run only
`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`	output the result
`public void` `output_histogram(std::ostream &) const`
`public inline void` `operator<<(const` `HistogramObservableData< T > & obs)`
`public inline virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public inline virtual void` `save(ODump & dump) const`
`public inline virtual void` `load(IDump & dump)`
`public inline virtual void` `merge(const` `Observable` `&)`
`public inline virtual bool` `can_merge() const`	can this observable be merged with one of the same type
`public inline virtual bool` `can_merge(const` `Observable` `&) const`	can this observable be merged with one of the given type
`public inline virtual` `Observable*convert_mergeable() const`	create a copy of the observable that can be merged
`public inline virtual` `HistogramObservableEvaluator< T >` `make_evaluator() const`
`typedef` `value_type`
`typedef` `range_type`
`typedef` `count_type`
`typedef` `iterator`
`typedef` `const_iterator`

Members

`public` `BOOST_STATIC_CONSTANT(uint32_t,version)`

`public inline` `HistogramObservableEvaluator(const std::string & n)`

`public inline` `HistogramObservableEvaluator(const char * n)`

`public inline` `HistogramObservableEvaluator(const` `HistogramObservableEvaluator` `& eval)`

`public inline` `HistogramObservableEvaluator(const` `Observable` `& obs,const std::string &)`

`public inline` `HistogramObservableEvaluator(const` `Observable` `&)`

`public inline` `HistogramObservableEvaluator(const std::string & n,std::istream &,const XMLTag &)`

`public inline virtual` `~HistogramObservableEvaluator()`

`public inline const` `HistogramObservableEvaluator< T > &` `operator=(const` `HistogramObservableEvaluator< T > & eval)`

`public inline const` `HistogramObservableEvaluator< T > &` `operator=(const` `HistogramObservable< T > & obs)`

`public inline` `HistogramObservableEvaluator< T > &` `operator<<(const` `HistogramObservable< T > & obs)`

`public inline virtual void` `rename(const std::string &)`

rename the observable

`public inline void` `rename(const std::string n,bool a)`

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public inline value_type` `operator[](int i) const`

`public inline count_type` `count() const`

`public inline virtual` `Observable*clone() const`

clones the observable

`public inline virtual uint32_t` `number_of_runs() const`

get the number of runs which performed measurements for this observable

`public inline virtual` `Observable*get_run(uint32_t) const`

extract an observable from a specific run only

`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

output the result

`public void` `output_histogram(std::ostream &) const`

`public inline void` `operator<<(const` `HistogramObservableData< T > & obs)`

`public inline virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public inline virtual void` `save(ODump & dump) const`

`public inline virtual void` `load(IDump & dump)`

`public inline virtual void` `merge(const` `Observable` `&)`

`public inline virtual bool` `can_merge() const`

can this observable be merged with one of the same type

`public inline virtual bool` `can_merge(const` `Observable` `&) const`

can this observable be merged with one of the given type

`public inline virtual` `Observable*convert_mergeable() const`

create a copy of the observable that can be merged

`public inline virtual` `HistogramObservableEvaluator< T >` `make_evaluator() const`

`typedef` `value_type`

`typedef` `range_type`

`typedef` `count_type`

`typedef` `iterator`

`typedef` `const_iterator`

class `alps::NoBinning`

class alps::NoBinning
  : public alps::AbstractBinning< double >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`
`public` `BOOST_STATIC_CONSTANT(int,magic_id)`
`public inline` `NoBinning(uint32_t,uint32_t)`
`public inline void` `reset(bool)`
`public inline void` `operator<<(const value_type & x)`
`public inline result_type` `mean() const`
`public inline result_type` `variance() const`
`public inline result_type` `error(uint32_t) const`
`public convergence_type` `converged_errors() const`
`public inline uint32_t` `count() const`
`public inline void` `set_bin_size(count_type)`
`public inline void` `set_bin_number(count_type)`
`public inline void` `output_scalar(std::ostream & out) const`
`public template<>` `inline void` `output_vector(std::ostream & out,const L & l) const`
`public inline void` `save(ODump & dump) const`
`public inline void` `load(IDump & dump)`
`public inline void` `save(hdf5::archive &) const`
`public inline void` `load(hdf5::archive &)`
`typedef` `value_type`
`typedef` `size_type`
`typedef` `count_type`
`typedef` `result_type`
`typedef` `convergence_type`

Members

`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`

`public` `BOOST_STATIC_CONSTANT(int,magic_id)`

`public inline` `NoBinning(uint32_t,uint32_t)`

`public inline void` `reset(bool)`

`public inline void` `operator<<(const value_type & x)`

`public inline result_type` `mean() const`

`public inline result_type` `variance() const`

`public inline result_type` `error(uint32_t) const`

`public convergence_type` `converged_errors() const`

`public inline uint32_t` `count() const`

`public inline void` `set_bin_size(count_type)`

`public inline void` `set_bin_number(count_type)`

`public inline void` `output_scalar(std::ostream & out) const`

`public template<>`
`inline void` `output_vector(std::ostream & out,const L & l) const`

`public inline void` `save(ODump & dump) const`

`public inline void` `load(IDump & dump)`

`public inline void` `save(hdf5::archive &) const`

`public inline void` `load(hdf5::archive &)`

`typedef` `value_type`

`typedef` `size_type`

`typedef` `count_type`

`typedef` `result_type`

`typedef` `convergence_type`

class `alps::NoMeasurementsError`

class alps::NoMeasurementsError
  : public std::runtime_error

an error class if no measurement was performed

Summary

Members	Descriptions
`public inline` `NoMeasurementsError()`

Members

`public inline` `NoMeasurementsError()`

class `alps::Observable`

the base class for all observables

Summary

Members	Descriptions
`public` `Observable(const std::string & n)`	standard constructors: just assign the name
`public` `Observable(const` `Observable` `& o)`
`public virtual` `~Observable()`	dtor
`public virtual` `Observable*clone() const`	clones the observable
`public const std::string &` `name() const`	returns the name
`public virtual void` `rename(const std::string &)`	rename the observable
`public virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`	output the result
`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`	output the result
`public virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public virtual void` `save(ODump & dump) const`
`public virtual void` `load(IDump & dump)`
`public virtual void` `save(hdf5::archive &) const`
`public virtual void` `load(hdf5::archive &)`
`public virtual bool` `is_signed() const`	is the observable signed?
`public virtual void` `set_sign_name(const std::string & signname)`	set the name of the observable containing the sign for this observable
`public virtual void` `set_sign(const` `Observable` `& sign)`	set the observable containing the sign
`public virtual void` `clear_sign()`	clear any previosuly set sign observable
`public virtual const` `Observable&sign() const`	get a reference to the sign observable
`public virtual const` `Observable&signed_observable() const`
`public virtual const std::string` `sign_name() const`	get the name of the observable containing the sign
`public virtual uint32_t` `number_of_runs() const`	get the number of runs which performed measurements for this observable
`public virtual` `Observable*get_run(uint32_t) const`	extract an observable from a specific run only
`public virtual void` `merge(const` `Observable` `&)`
`public virtual bool` `can_merge() const`	can this observable be merged with one of the same type
`public virtual bool` `can_merge(const` `Observable` `&) const`	can this observable be merged with one of the given type
`public virtual` `Observable*convert_mergeable() const`	create a copy of the observable that can be merged
`public template<>` `inline void` `operator<<(const T & x)`	merge this observable with another or add measurement
`public template<>` `inline void` `add(const T & x)`
`public template<>` `inline void` `add(const T & x,S s)`
`typedef` `version_type`

Members

`public` `Observable(const std::string & n)`

standard constructors: just assign the name

`public` `Observable(const` `Observable` `& o)`

`public virtual` `~Observable()`

dtor

`public virtual` `Observable*clone() const`

clones the observable

`public const std::string &` `name() const`

returns the name

`public virtual void` `rename(const std::string &)`

rename the observable

`public virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

output the result

`public virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`

output the result

`public virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public virtual void` `save(ODump & dump) const`

`public virtual void` `load(IDump & dump)`

`public virtual void` `save(hdf5::archive &) const`

`public virtual void` `load(hdf5::archive &)`

`public virtual bool` `is_signed() const`

is the observable signed?

`public virtual void` `set_sign_name(const std::string & signname)`

set the name of the observable containing the sign for this observable

`public virtual void` `set_sign(const` `Observable` `& sign)`

set the observable containing the sign

`public virtual void` `clear_sign()`

clear any previosuly set sign observable

`public virtual const` `Observable&sign() const`

get a reference to the sign observable

`public virtual const` `Observable&signed_observable() const`

`public virtual const std::string` `sign_name() const`

get the name of the observable containing the sign

`public virtual uint32_t` `number_of_runs() const`

get the number of runs which performed measurements for this observable

`public virtual` `Observable*get_run(uint32_t) const`

extract an observable from a specific run only

`public virtual void` `merge(const` `Observable` `&)`

`public virtual bool` `can_merge() const`

can this observable be merged with one of the same type

`public virtual bool` `can_merge(const` `Observable` `&) const`

can this observable be merged with one of the given type

`public virtual` `Observable*convert_mergeable() const`

create a copy of the observable that can be merged

`public template<>`
`inline void` `operator<<(const T & x)`

merge this observable with another or add measurement

`public template<>`
`inline void` `add(const T & x)`

`public template<>`
`inline void` `add(const T & x,S s)`

`typedef` `version_type`

class `alps::ObservableFactory`

class alps::ObservableFactory
  : public factory< uint32_t, Observable >

A class to collect the various measurements performed in a simulation It is implemented as a map, with std::string as key type

Summary

Members	Descriptions
`public` `ObservableFactory()`
`public template<>` `inline void` `register_observable()`

Members

`public` `ObservableFactory()`

`public template<>`
`inline void` `register_observable()`

class `alps::ObservableSet`

class alps::ObservableSet
  : public std::map< std::string, Observable * >

Summary

Members	Descriptions
`public inline` `ObservableSet()`	the default constructor
`public` `ObservableSet(const` `ObservableSet` `& m)`	sign problem support requires a non-trivial copy constructor
`public virtual` `~ObservableSet()`	a non-trivial destructor
`public` `ObservableSet&operator=(const` `ObservableSet` `& m)`	sign problem support requires non-trivial assignment
`public` `ObservableSet&operator<<(const` `ObservableSet` `& obs)`	merge two observable set. If observables with identical names exist in both sets, a merger of the observables is attempted. In case of failure an exception is thrown.
`public` `ObservableSet&operator<<(const` `Observable` `& obs)`	merge an observable into the set. If an observables with identical names exists, a merger of the observables is attempted. In case of failure an exception is thrown.
`public inline` `ObservableSet&operator<<(const boost::shared_ptr<` `Observable` `> & obs)`
`public void` `addObservable(Observable` `* obs)`	add an observable to the set. The ObservableSet will delete the object at the end. If an observable with the same name exists, it is replaced. This is different behavior than operator«.
`public void` `addObservable(const` `Observable` `& obs)`
`public void` `removeObservable(const std::string & name)`	remove an observable with a given name
`public` `Observable&operator[](const std::string & name)`	get an observable with the given name
`public const` `Observable&operator[](const std::string & name) const`	get an observable with the given name
`public bool` `has(const std::string & name) const`	check if an observable with the given name exists
`public void` `reset(bool)`	reset all observables
`public template<>` `inline void` `do_for_all(F f) const`	apply a unary function to all observables
`public template<>` `inline void` `do_for_all(F f)`	apply a unary function to all observables
`public template<>` `inline T &` `get(const std::string & name)`	get an observable with the given name and type
`public template<>` `inline const T &` `get(const std::string & name) const`	get an observable with the given name and type
`public uint32_t` `number_of_runs() const`	the number of runs from which the observables were collected. Care must be taken that if some observables did not occur in all sets the numbering is not consistent and problems can result.
`public` `ObservableSet` `get_run(uint32_t) const`	the number of runs from which the observables were collected. Care must be taken that if some observables did not occur in all sets the numbering is not consistent and problems can result.
`public virtual void` `save(ODump & dump) const`
`public virtual void` `load(IDump & dump)`
`public virtual void` `save(hdf5::archive &) const`
`public virtual void` `load(hdf5::archive &)`
`public template<>` `inline void` `save(Archive & ar,const unsigned int) const`	support for Boost serialization
`public template<>` `inline void` `load(Archive & ar,const unsigned int)`	support for Boost serialization
`public void` `update_signs()`
`public void` `set_sign(const std::string &)`
`public inline void` `compact()`	compact the observables to save space, discarding e.g. time series information
`public void` `write_xml(oxstream & oxs,const boost::filesystem::path &) const`
`public void` `write_xml_with_id(oxstream & oxs,int id,const boost::filesystem::path &) const`
`public void` `read_xml(std::istream & infile,const XMLTag & tag)`
`public void` `write_hdf5(boost::filesystem::path const &,std::size_t realization,std::size_t clone) const`
`public void` `read_hdf5(boost::filesystem::path const &,std::size_t realization,std::size_t clone)`
`public void` `clear()`

Members

`public inline` `ObservableSet()`

the default constructor

`public` `ObservableSet(const` `ObservableSet` `& m)`

sign problem support requires a non-trivial copy constructor

`public virtual` `~ObservableSet()`

a non-trivial destructor

`public` `ObservableSet&operator=(const` `ObservableSet` `& m)`

sign problem support requires non-trivial assignment

`public` `ObservableSet&operator<<(const` `ObservableSet` `& obs)`

merge two observable set. If observables with identical names exist in both sets, a merger of the observables is attempted. In case of failure an exception is thrown.

Exceptions

std::bad_cast if merging fails

`public` `ObservableSet&operator<<(const` `Observable` `& obs)`

merge an observable into the set. If an observables with identical names exists, a merger of the observables is attempted. In case of failure an exception is thrown.

Exceptions

std::bad_cast if merging fails

`public inline` `ObservableSet&operator<<(const boost::shared_ptr<` `Observable` `> & obs)`

`public void` `addObservable(Observable` `* obs)`

add an observable to the set. The ObservableSet will delete the object at the end. If an observable with the same name exists, it is replaced. This is different behavior than operator«.

`public void` `addObservable(const` `Observable` `& obs)`

`public void` `removeObservable(const std::string & name)`

remove an observable with a given name

`public` `Observable&operator[](const std::string & name)`

get an observable with the given name

Exceptions

throws a std::runtime_error if no observable exists with the given name

`public const` `Observable&operator[](const std::string & name) const`

get an observable with the given name

Exceptions

throws a std::runtime_error if no observable exists with the given name

`public bool` `has(const std::string & name) const`

check if an observable with the given name exists

`public void` `reset(bool)`

reset all observables

Parameters

flag a value of true means that reset is called after thermalization and information about thermalization should be kept.

`public template<>`
`inline void` `do_for_all(F f) const`

apply a unary function to all observables

`public template<>`
`inline void` `do_for_all(F f)`

apply a unary function to all observables

`public template<>`
`inline T &` `get(const std::string & name)`

get an observable with the given name and type

Exceptions

throws a std::runtime_error if no observable exists with the given name

`public template<>`
`inline const T &` `get(const std::string & name) const`

get an observable with the given name and type

Exceptions

throws a std::runtime_error if no observable exists with the given name

`public uint32_t` `number_of_runs() const`

the number of runs from which the observables were collected. Care must be taken that if some observables did not occur in all sets the numbering is not consistent and problems can result.

`public` `ObservableSet` `get_run(uint32_t) const`

the number of runs from which the observables were collected. Care must be taken that if some observables did not occur in all sets the numbering is not consistent and problems can result.

`public virtual void` `save(ODump & dump) const`

`public virtual void` `load(IDump & dump)`

`public virtual void` `save(hdf5::archive &) const`

`public virtual void` `load(hdf5::archive &)`

`public template<>`
`inline void` `save(Archive & ar,const unsigned int) const`

support for Boost serialization

`public template<>`
`inline void` `load(Archive & ar,const unsigned int)`

support for Boost serialization

`public void` `update_signs()`

`public void` `set_sign(const std::string &)`

`public inline void` `compact()`

compact the observables to save space, discarding e.g. time series information

`public void` `write_xml(oxstream & oxs,const boost::filesystem::path &) const`

`public void` `write_xml_with_id(oxstream & oxs,int id,const boost::filesystem::path &) const`

`public void` `read_xml(std::istream & infile,const XMLTag & tag)`

`public void` `write_hdf5(boost::filesystem::path const &,std::size_t realization,std::size_t clone) const`

`public void` `read_hdf5(boost::filesystem::path const &,std::size_t realization,std::size_t clone)`

`public void` `clear()`

class `alps::ObservableSetXMLHandler`

class alps::ObservableSetXMLHandler
  : public CompositeXMLHandler

XML parser for the ObservableSet class.

Summary

Members	Descriptions
`public` `ObservableSetXMLHandler(ObservableSet` `& obs)`
`protected void` `end_child(std::string const & name,xml::tag_type type)`

Members

`public` `ObservableSetXMLHandler(ObservableSet` `& obs)`

`protected void` `end_child(std::string const & name,xml::tag_type type)`

class `alps::ObsValueXMLHandler`

class alps::ObsValueXMLHandler
  : public XMLHandlerBase

Summary

Members	Descriptions
`public` `ObsValueXMLHandler(const std::string & basename,double & val,const std::string & attr)`
`public inline virtual` `~ObsValueXMLHandler()`
`public virtual void` `start_element(const std::string & name,const XMLAttributes & attributes,xml::tag_type type)`
`public virtual void` `end_element(const std::string & name,xml::tag_type type)`
`public virtual void` `text(const std::string & text)`

Members

`public` `ObsValueXMLHandler(const std::string & basename,double & val,const std::string & attr)`

`public inline virtual` `~ObsValueXMLHandler()`

`public virtual void` `start_element(const std::string & name,const XMLAttributes & attributes,xml::tag_type type)`

`public virtual void` `end_element(const std::string & name,xml::tag_type type)`

`public virtual void` `text(const std::string & text)`

class `alps::RealHistogramEntryXMLHandler`

class alps::RealHistogramEntryXMLHandler
  : public CompositeXMLHandler

XML parser for the entries for RealHistogramObservable class.

Summary

Members	Descriptions
`public` `RealHistogramEntryXMLHandler(uint64_t & count,uint64_t & value)`
`public inline virtual` `~RealHistogramEntryXMLHandler()`

Members

`public` `RealHistogramEntryXMLHandler(uint64_t & count,uint64_t & value)`

`public inline virtual` `~RealHistogramEntryXMLHandler()`

class `alps::RealHistogramObservableXMLHandler`

class alps::RealHistogramObservableXMLHandler
  : public CompositeXMLHandler

XML parser for the RealHistogramObservable class.

Summary

Members	Descriptions
`public` `RealHistogramObservableXMLHandler(RealHistogramObservable` `& obs)`
`public inline virtual` `~RealHistogramObservableXMLHandler()`
`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`
`protected void` `end_child(const std::string & name,xml::tag_type type)`

Members

`public` `RealHistogramObservableXMLHandler(RealHistogramObservable` `& obs)`

`public inline virtual` `~RealHistogramObservableXMLHandler()`

`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`

`protected void` `end_child(const std::string & name,xml::tag_type type)`

class `alps::RealObsevaluatorValueXMLHandler`

class alps::RealObsevaluatorValueXMLHandler
  : public XMLHandlerBase

XML parser for the elements for RealObsevaluator class.

Summary

Members	Descriptions
`public` `RealObsevaluatorValueXMLHandler(std::string const & name,double & value,std::string & method,int & conv)`
`public inline virtual` `~RealObsevaluatorValueXMLHandler()`
`public void` `start_element(const std::string & name,const XMLAttributes & attributes,xml::tag_type type)`
`public void` `end_element(const std::string & name,xml::tag_type type)`
`public void` `text(const std::string & text)`

Members

`public` `RealObsevaluatorValueXMLHandler(std::string const & name,double & value,std::string & method,int & conv)`

`public inline virtual` `~RealObsevaluatorValueXMLHandler()`

`public void` `start_element(const std::string & name,const XMLAttributes & attributes,xml::tag_type type)`

`public void` `end_element(const std::string & name,xml::tag_type type)`

`public void` `text(const std::string & text)`

class `alps::RealObsevaluatorXMLHandler`

class alps::RealObsevaluatorXMLHandler
  : public CompositeXMLHandler

XML parser for the RealObsevaluator class.

Summary

Members	Descriptions
`public` `RealObsevaluatorXMLHandler(RealObsevaluator` `& obs,std::string & index)`
`public inline virtual` `~RealObsevaluatorXMLHandler()`
`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`
`protected void` `end_child(const std::string & name,xml::tag_type type)`

Members

`public` `RealObsevaluatorXMLHandler(RealObsevaluator` `& obs,std::string & index)`

`public inline virtual` `~RealObsevaluatorXMLHandler()`

`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`

`protected void` `end_child(const std::string & name,xml::tag_type type)`

class `alps::RealVectorObsevaluatorXMLHandler`

class alps::RealVectorObsevaluatorXMLHandler
  : public CompositeXMLHandler

XML parser for the RealVectorObsevaluator class.

Summary

Members	Descriptions
`public` `RealVectorObsevaluatorXMLHandler(RealVectorObsevaluator` `& obs)`
`public inline virtual` `~RealVectorObsevaluatorXMLHandler()`
`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`
`protected void` `end_child(const std::string & name,xml::tag_type type)`

Members

`public` `RealVectorObsevaluatorXMLHandler(RealVectorObsevaluator` `& obs)`

`public inline virtual` `~RealVectorObsevaluatorXMLHandler()`

`protected void` `start_top(const std::string &,const XMLAttributes &,xml::tag_type)`

`protected void` `end_child(const std::string & name,xml::tag_type type)`

class `alps::RecordableObservable`

Summary

Members	Descriptions
`public inline` `RecordableObservable()`	just a default constructor
`public inline virtual` `~RecordableObservable()`
`public void` `operator<<(const value_type & x)`	add another measurement to the observable
`public inline virtual void` `add(const value_type & x)`	add another measurement to the observable
`public inline virtual void` `add(const value_type & x,sign_type s)`	add an explcitly signed measurement to the observable
`typedef` `value_type`
`typedef` `sign_type`

Members

`public inline` `RecordableObservable()`

just a default constructor

`public inline virtual` `~RecordableObservable()`

`public void` `operator<<(const value_type & x)`

add another measurement to the observable

`public inline virtual void` `add(const value_type & x)`

add another measurement to the observable

`public inline virtual void` `add(const value_type & x,sign_type s)`

add an explcitly signed measurement to the observable

`typedef` `value_type`

`typedef` `sign_type`

class `alps::SignedObservable`

class alps::SignedObservable
  : public alps::AbstractSignedObservable< OBS, double >
  : public alps::RecordableObservable< OBS::value_type, double >

Summary

Members	Descriptions
`public inline` `SignedObservable(const OBS & obs,const std::string & s)`
`public inline` `SignedObservable(const std::string & name,const std::string & s,const label_type & l)`
`public inline` `SignedObservable(const std::string & name,const char * s,const label_type & l)`
`public template<>` `inline` `SignedObservable(const std::string & name,const ARG & arg,const label_type & l)`
`public template<>` `inline` `SignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)`
`public inline` `~SignedObservable()`
`public inline virtual` `Observable*clone() const`	clones the observable
`public inline void` `operator<<(const value_type & x)`
`public inline void` `add(const value_type & x)`
`public inline void` `add(const value_type & x,sign_type s)`
`public void` `write_hdf5(const boost::filesystem::path & fn_hdf,std::size_t realization,std::size_t clone) const`
`public void` `read_hdf5(const boost::filesystem::path & fn_hdf,std::size_t realization,std::size_t clone)`
`typedef` `observable_type`
`typedef` `sign_type`
`typedef` `base_type`
`typedef` `value_type`
`typedef` `result_type`
`typedef` `count_type`
`typedef` `time_type`
`typedef` `label_type`

Members

`public inline` `SignedObservable(const OBS & obs,const std::string & s)`

`public inline` `SignedObservable(const std::string & name,const std::string & s,const label_type & l)`

`public inline` `SignedObservable(const std::string & name,const char * s,const label_type & l)`

`public template<>`
`inline` `SignedObservable(const std::string & name,const ARG & arg,const label_type & l)`

`public template<>`
`inline` `SignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)`

`public inline` `~SignedObservable()`

`public inline virtual` `Observable*clone() const`

clones the observable

`public inline void` `operator<<(const value_type & x)`

`public inline void` `add(const value_type & x)`

`public inline void` `add(const value_type & x,sign_type s)`

`public void` `write_hdf5(const boost::filesystem::path & fn_hdf,std::size_t realization,std::size_t clone) const`

`public void` `read_hdf5(const boost::filesystem::path & fn_hdf,std::size_t realization,std::size_t clone)`

`typedef` `observable_type`

`typedef` `sign_type`

`typedef` `base_type`

`typedef` `value_type`

`typedef` `result_type`

`typedef` `count_type`

`typedef` `time_type`

`typedef` `label_type`

class `alps::SimpleBinning`

class alps::SimpleBinning
  : public alps::AbstractBinning< double >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`
`public` `BOOST_STATIC_CONSTANT(int,magic_id)`
`public inline` `SimpleBinning(std::size_t)`
`public inline void` `reset(bool)`
`public inline void` `operator<<(const T & x)`
`public inline uint64_t` `count() const`
`public inline result_type` `mean() const`
`public inline result_type` `variance() const`
`public inline result_type` `error(std::size_t bin_used) const`
`public inline double` `error_element(std::size_t element,std::size_t bin_used) const`
`public inline double` `binmean_element(std::size_t element,std::size_t i) const`
`public inline double` `binvariance_element(std::size_t element,std::size_t i) const`
`public inline double` `variance_element(std::size_t element) const`
`public convergence_type` `converged_errors() const`
`public inline time_type` `tau() const`
`public inline uint32_t` `binning_depth() const`
`public inline std::size_t` `size() const`
`public void` `output_scalar(std::ostream & out) const`
`public template<>` `inline void` `output_vector(std::ostream & out,const L &) const`
`public inline void` `save(ODump & dump) const`
`public inline void` `load(IDump & dump)`
`public inline void` `save(hdf5::archive &) const`
`public inline void` `load(hdf5::archive &)`
`public inline std::string` `evaluation_method() const`
`public void` `write_scalar_xml(oxstream & oxs) const`
`public template<>` `void` `write_vector_xml(oxstream & oxs,IT) const`
`public inline void` `operator<<(const std::valarray< double > & x)`
`public inline double` `binmean_element(std::size_t element,std::size_t i) const`
`public inline double` `binvariance_element(std::size_t element,std::size_t i) const`
`public inline double` `variance_element(std::size_t element) const`
`public inline double` `error_element(std::size_t element,std::size_t i) const`
`public void` `write_vector_xml(oxstream & oxs,IT it) const`
`typedef` `value_type`
`typedef` `time_type`
`typedef` `size_type`
`typedef` `count_type`
`typedef` `result_type`
`typedef` `convergence_type`

Members

`public` `BOOST_STATIC_CONSTANT(bool,has_tau)`

`public` `BOOST_STATIC_CONSTANT(int,magic_id)`

`public inline` `SimpleBinning(std::size_t)`

`public inline void` `reset(bool)`

`public inline void` `operator<<(const T & x)`

`public inline uint64_t` `count() const`

`public inline result_type` `mean() const`

`public inline result_type` `variance() const`

`public inline result_type` `error(std::size_t bin_used) const`

`public inline double` `error_element(std::size_t element,std::size_t bin_used) const`

`public inline double` `binmean_element(std::size_t element,std::size_t i) const`

`public inline double` `binvariance_element(std::size_t element,std::size_t i) const`

`public inline double` `variance_element(std::size_t element) const`

`public convergence_type` `converged_errors() const`

`public inline time_type` `tau() const`

`public inline uint32_t` `binning_depth() const`

`public inline std::size_t` `size() const`

`public void` `output_scalar(std::ostream & out) const`

`public template<>`
`inline void` `output_vector(std::ostream & out,const L &) const`

`public inline void` `save(ODump & dump) const`

`public inline void` `load(IDump & dump)`

`public inline void` `save(hdf5::archive &) const`

`public inline void` `load(hdf5::archive &)`

`public inline std::string` `evaluation_method() const`

`public void` `write_scalar_xml(oxstream & oxs) const`

`public template<>`
`void` `write_vector_xml(oxstream & oxs,IT) const`

`public inline void` `operator<<(const std::valarray< double > & x)`

`public inline double` `binmean_element(std::size_t element,std::size_t i) const`

`public inline double` `binvariance_element(std::size_t element,std::size_t i) const`

`public inline double` `variance_element(std::size_t element) const`

`public inline double` `error_element(std::size_t element,std::size_t i) const`

`public void` `write_vector_xml(oxstream & oxs,IT it) const`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `size_type`

`typedef` `count_type`

`typedef` `result_type`

`typedef` `convergence_type`

class `alps::SimpleObservable`

class alps::SimpleObservable
  : public alps::AbstractSimpleObservable< T >
  : public alps::RecordableObservable< T >

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(int,version)`
`public inline` `SimpleObservable(const std::string & name,const label_type & l)`	the constructor needs a name and optionally specifications for the binning strategy
`public inline` `SimpleObservable(const std::string & name,const binning_type & b,const label_type & l)`
`public inline` `SimpleObservable(const std::string & name,uint32_t s,const label_type & l)`
`public inline` `SimpleObservable(const std::string & name,uint32_t s,uint32_t a,const label_type & l)`
`public inline virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public inline virtual` `Observable*clone() const`	clones the observable
`public virtual void` `output(std::ostream &) const`	output the result
`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public inline virtual result_type` `mean() const`	the mean value
`public inline virtual bool` `has_variance() const`	is variance available ?
`public inline virtual result_type` `variance() const`	the variance
`public inline virtual result_type` `error() const`	the error
`public inline result_type` `error(unsigned bin_used) const`
`public inline virtual convergence_type` `converged_errors() const`
`public inline virtual count_type` `count() const`	the number of measurements
`public inline virtual bool` `has_tau() const`	is autocorrelation information available ?
`public inline virtual time_type` `tau() const`	the autocorrelation time, throws an exception if not available
`public inline std::string` `representation() const`
`public inline virtual void` `operator<<(const T & x)`	add another measurement to the observable
`public inline virtual count_type` `bin_size() const`	the number of measurements per bin
`public inline void` `set_bin_size(count_type s)`	resize bins to contain at least the given number of entries
`public inline virtual count_type` `bin_number() const`	the number of bins
`public inline virtual count_type` `bin_number2() const`	the number of bins with squared values
`public inline virtual count_type` `max_bin_number() const`	get the maximum number of bins
`public inline void` `set_bin_number(count_type n)`	set the maximum number of bins This will be the maximum number from now on if additional measurements are performed.
`public inline virtual const value_type &` `bin_value(count_type) const`	the value of a bin
`public inline virtual const value_type &` `bin_value2(count_type) const`	the squared value of a bin
`public inline const std::vector< value_type > &` `bins() const`
`public inline virtual void` `save(ODump & dump) const`
`public inline virtual void` `load(IDump & dump)`
`public inline void` `extract_timeseries(ODump & dump) const`
`public virtual void` `save(hdf5::archive &) const`
`public virtual void` `load(hdf5::archive &)`
`public inline virtual std::string` `evaluation_method(Target t) const`
`typedef` `value_type`
`typedef` `time_type`
`typedef` `count_type`
`typedef` `result_type`
`typedef` `slice_index`
`typedef` `label_type`
`typedef` `convergence_type`
`typedef` `binning_type`

Members

`public` `BOOST_STATIC_CONSTANT(int,version)`

`public inline` `SimpleObservable(const std::string & name,const label_type & l)`

the constructor needs a name and optionally specifications for the binning strategy

`public inline` `SimpleObservable(const std::string & name,const binning_type & b,const label_type & l)`

`public inline` `SimpleObservable(const std::string & name,uint32_t s,const label_type & l)`

`public inline` `SimpleObservable(const std::string & name,uint32_t s,uint32_t a,const label_type & l)`

`public inline virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public inline virtual` `Observable*clone() const`

clones the observable

`public virtual void` `output(std::ostream &) const`

output the result

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public inline virtual result_type` `mean() const`

the mean value

`public inline virtual bool` `has_variance() const`

is variance available ?

`public inline virtual result_type` `variance() const`

the variance

`public inline virtual result_type` `error() const`

the error

`public inline result_type` `error(unsigned bin_used) const`

`public inline virtual convergence_type` `converged_errors() const`

`public inline virtual count_type` `count() const`

the number of measurements

`public inline virtual bool` `has_tau() const`

is autocorrelation information available ?

`public inline virtual time_type` `tau() const`

the autocorrelation time, throws an exception if not available

`public inline std::string` `representation() const`

`public inline virtual void` `operator<<(const T & x)`

add another measurement to the observable

`public inline virtual count_type` `bin_size() const`

the number of measurements per bin

`public inline void` `set_bin_size(count_type s)`

resize bins to contain at least the given number of entries

`public inline virtual count_type` `bin_number() const`

the number of bins

`public inline virtual count_type` `bin_number2() const`

the number of bins with squared values

`public inline virtual count_type` `max_bin_number() const`

get the maximum number of bins

`public inline void` `set_bin_number(count_type n)`

set the maximum number of bins This will be the maximum number from now on if additional measurements are performed.

`public inline virtual const value_type &` `bin_value(count_type) const`

the value of a bin

`public inline virtual const value_type &` `bin_value2(count_type) const`

the squared value of a bin

`public inline const std::vector< value_type > &` `bins() const`

`public inline virtual void` `save(ODump & dump) const`

`public inline virtual void` `load(IDump & dump)`

`public inline void` `extract_timeseries(ODump & dump) const`

`public virtual void` `save(hdf5::archive &) const`

`public virtual void` `load(hdf5::archive &)`

`public inline virtual std::string` `evaluation_method(Target t) const`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `count_type`

`typedef` `result_type`

`typedef` `slice_index`

`typedef` `label_type`

`typedef` `convergence_type`

`typedef` `binning_type`

class `alps::SimpleObservableData`

Summary

Members	Descriptions
`public` `SimpleObservableData()`
`public template<>` `inline` `SimpleObservableData(const` `SimpleObservableData< U > & x,S s)`
`public` `SimpleObservableData(const` `AbstractSimpleObservable< value_type > & obs)`
`public` `SimpleObservableData(std::istream &,const XMLTag &,label_type &)`
`public inline` `SimpleObservableDataconst &operator=(const` `SimpleObservableData` `& x)`
`public inline void` `read_xml(std::istream &,const XMLTag &,label_type & label)`
`public void` `read_xml_scalar(std::istream &,const XMLTag &)`
`public void` `read_xml_vector(std::istream &,const XMLTag &,label_type & label)`
`public inline ALPS_DUMMY_VOID` `set_thermalization(uint32_t todiscard)`
`public inline uint32_t` `get_thermalization() const`
`public inline bool` `can_set_thermalization() const`
`public inline uint64_t` `count() const`
`public inline const result_type &` `mean() const`
`public inline const result_type &` `error() const`
`public inline const convergence_type &` `converged_errors() const`
`public inline const convergence_type &` `any_converged_errors() const`
`public inline const result_type &` `variance() const`
`public inline const time_type &` `tau() const`
`public covariance_type` `covariance(const` `SimpleObservableData< T >) const`
`public inline bool` `has_variance() const`
`public inline bool` `has_tau() const`
`public inline uint64_t` `bin_size() const`
`public inline std::size_t` `bin_number() const`
`public inline std::size_t` `bin_number2() const`
`public inline const value_type &` `bin_value(std::size_t i) const`
`public inline const value_type &` `bin_value2(std::size_t i) const`
`public inline const std::vector< value_type > &` `bins() const`
`public template<>` `inline` `SimpleObservableData< typename element_type< T >::type >` `slice(S s) const`
`public ALPS_DUMMY_VOID` `compact()`
`public void` `extract_timeseries(ODump & dump) const`
`public void` `save(ODump & dump) const`
`public void` `load(IDump & dump)`
`public void` `save(hdf5::archive &) const`
`public void` `load(hdf5::archive &)`
`public inline void` `set_bin_size(uint64_t)`
`public inline void` `set_bin_number(std::size_t)`
`public` `SimpleObservableData< T > &` `operator<<(const` `SimpleObservableData< T > & b)`
`public void` `negate()`
`public template<>` `SimpleObservableData< T > &` `operator+=(X)`
`public template<>` `SimpleObservableData< T > &` `operator-=(X)`
`public template<>` `SimpleObservableData< T > &` `operator*=(X)`
`public template<>` `SimpleObservableData< T > &` `operator/=(X)`
`public template<>` `void` `subtract_from(const X & x)`
`public template<>` `void` `divide(const X & x)`
`public` `SimpleObservableData< T > &` `operator+=(const` `SimpleObservableData< T > &)`
`public` `SimpleObservableData< T > &` `operator-=(const` `SimpleObservableData< T > &)`
`public template<>` `SimpleObservableData< T > &` `operator*=(const` `SimpleObservableData< X > &)`
`public template<>` `SimpleObservableData< T > &` `operator/=(const` `SimpleObservableData< X > &)`
`public template<>` `void` `transform(OP op)`
`public std::string` `evaluation_method(Target t) const`
`protected void` `collect_bins(std::size_t howmany)`
`protected void` `analyze() const`
`protected void` `jackknife() const`
`protected void` `fill_jack() const`
`protected template<>` `void` `transform(const` `SimpleObservableData< X > & x,OP op,double factor)`
`protected template<>` `void` `transform_linear(OP op)`
`typedef` `value_type`
`typedef` `time_type`
`typedef` `size_type`
`typedef` `count_type`
`typedef` `result_type`
`typedef` `convergence_type`
`typedef` `label_type`
`typedef` `covariance_type`

Members

`public` `SimpleObservableData()`

`public template<>`
`inline` `SimpleObservableData(const` `SimpleObservableData & x,S s)`

`public` `SimpleObservableData(const` `AbstractSimpleObservable< value_type > & obs)`

`public` `SimpleObservableData(std::istream &,const XMLTag &,label_type &)`

`public inline` `SimpleObservableDataconst &operator=(const` `SimpleObservableData` `& x)`

`public inline void` `read_xml(std::istream &,const XMLTag &,label_type & label)`

`public void` `read_xml_scalar(std::istream &,const XMLTag &)`

`public void` `read_xml_vector(std::istream &,const XMLTag &,label_type & label)`

`public inline ALPS_DUMMY_VOID` `set_thermalization(uint32_t todiscard)`

`public inline uint32_t` `get_thermalization() const`

`public inline bool` `can_set_thermalization() const`

`public inline uint64_t` `count() const`

`public inline const result_type &` `mean() const`

`public inline const result_type &` `error() const`

`public inline const convergence_type &` `converged_errors() const`

`public inline const convergence_type &` `any_converged_errors() const`

`public inline const result_type &` `variance() const`

`public inline const time_type &` `tau() const`

`public covariance_type` `covariance(const` `SimpleObservableData< T >) const`

`public inline bool` `has_variance() const`

`public inline bool` `has_tau() const`

`public inline uint64_t` `bin_size() const`

`public inline std::size_t` `bin_number() const`

`public inline std::size_t` `bin_number2() const`

`public inline const value_type &` `bin_value(std::size_t i) const`

`public inline const value_type &` `bin_value2(std::size_t i) const`

`public inline const std::vector< value_type > &` `bins() const`

`public template<>`
`inline` `SimpleObservableData< typename element_type< T >::type >` `slice(S s) const`

`public ALPS_DUMMY_VOID` `compact()`

`public void` `extract_timeseries(ODump & dump) const`

`public void` `save(ODump & dump) const`

`public void` `load(IDump & dump)`

`public void` `save(hdf5::archive &) const`

`public void` `load(hdf5::archive &)`

`public inline void` `set_bin_size(uint64_t)`

`public inline void` `set_bin_number(std::size_t)`

`public` `SimpleObservableData< T > &` `operator<<(const` `SimpleObservableData< T > & b)`

`public void` `negate()`

`public template<>`
`SimpleObservableData< T > &` `operator+=(X)`

`public template<>`
`SimpleObservableData< T > &` `operator-=(X)`

`public template<>`
`SimpleObservableData< T > &` `operator*=(X)`

`public template<>`
`SimpleObservableData< T > &` `operator/=(X)`

`public template<>`
`void` `subtract_from(const X & x)`

`public template<>`
`void` `divide(const X & x)`

`public` `SimpleObservableData< T > &` `operator+=(const` `SimpleObservableData< T > &)`

`public` `SimpleObservableData< T > &` `operator-=(const` `SimpleObservableData< T > &)`

`public template<>`
`SimpleObservableData< T > &` `operator*=(const` `SimpleObservableData< X > &)`

`public template<>`
`SimpleObservableData< T > &` `operator/=(const` `SimpleObservableData< X > &)`

`public template<>`
`void` `transform(OP op)`

`public std::string` `evaluation_method(Target t) const`

`protected void` `collect_bins(std::size_t howmany)`

`protected void` `analyze() const`

`protected void` `jackknife() const`

`protected void` `fill_jack() const`

`protected template<>`
`void` `transform(const` `SimpleObservableData< X > & x,OP op,double factor)`

`protected template<>`
`void` `transform_linear(OP op)`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `size_type`

`typedef` `count_type`

`typedef` `result_type`

`typedef` `convergence_type`

`typedef` `label_type`

`typedef` `covariance_type`

class `alps::SimpleObservableEvaluator`

class alps::SimpleObservableEvaluator
  : public alps::AbstractSimpleObservable< T >

Summary

Members	Descriptions
`public inline virtual uint32_t` `version_id() const`	return a version ID uniquely identifying the class
`public inline` `SimpleObservableEvaluator(const std::string & n)`	almost default constructor
`public inline` `SimpleObservableEvaluator(const char * n)`
`public inline` `SimpleObservableEvaluator(const` `SimpleObservableEvaluator` `& eval)`	copy constructor
`public inline` `SimpleObservableEvaluator(const` `Observable` `& obs,const std::string & n)`	constructor from an observable
`public inline` `SimpleObservableEvaluator(const` `Observable` `& obs)`
`public inline` `SimpleObservableEvaluator(const std::string & n,std::istream &,const XMLTag &)`
`public inline const` `SimpleObservableEvaluator< T > &` `operator=(const` `SimpleObservableEvaluator< T > & eval)`	needed for silcing: assign an observable, replacing all observables in the class
`public inline const` `SimpleObservableEvaluator< T > &` `operator=(const` `AbstractSimpleObservable< T > & obs)`
`public inline` `SimpleObservableEvaluator< T > &` `operator<<(const` `AbstractSimpleObservable< T > & obs)`	add an observable to the ones already in the class
`public inline virtual void` `rename(const std::string &)`	rename the observable
`public inline void` `rename(const std::string & n,bool a)`
`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`	reset the observable
`public inline virtual bool` `has_tau() const`	is autocorrelation information available ?
`public inline virtual bool` `has_variance() const`	is variance available ?
`public inline result_type` `value() const`
`public inline virtual result_type` `mean() const`	the mean value
`public inline virtual result_type` `variance() const`	the variance
`public inline virtual result_type` `error() const`	the error
`public inline virtual convergence_type` `converged_errors() const`
`public inline virtual time_type` `tau() const`	the autocorrelation time, throws an exception if not available
`public inline covariance_type` `covariance(SimpleObservableEvaluator` `& obs2) const`
`public inline virtual count_type` `bin_number() const`	the number of bins
`public inline virtual const value_type &` `bin_value(count_type) const`	the value of a bin
`public inline virtual count_type` `bin_number2() const`	the number of bins with squared values
`public inline virtual const value_type &` `bin_value2(count_type) const`	the squared value of a bin
`public inline virtual count_type` `bin_size() const`	the number of measurements per bin
`public inline virtual count_type` `count() const`	the number of measurements
`public inline const std::vector< value_type > &` `bins() const`
`public inline virtual` `Observable*clone() const`	clones the observable
`public inline uint32_t` `get_thermalization() const`
`public inline bool` `can_set_thermalization() const`
`public inline ALPS_DUMMY_VOID` `compact()`
`public inline` `SimpleObservableEvaluator< T >` `operator-() const`	negate
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator+=(const X &)`	add a constant
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator-=(const X &)`	subtract a constant
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator*=(const X &)`	multiply with a constant
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator/=(const X &)`	divide by a constant
`public inline const` `SimpleObservableEvaluator< T > &` `operator+=(const` `SimpleObservableEvaluator< T > &)`	add another observable
`public inline const` `SimpleObservableEvaluator< T > &` `operator-=(const` `SimpleObservableEvaluator< T > &)`	subtract another observable
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator*=(const` `SimpleObservableEvaluator< X > &)`	multiply by another observable
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `operator/=(const` `SimpleObservableEvaluator< X > &)`	divide by another observable
`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`	output the result
`public void` `output_scalar(std::ostream &) const`
`public void` `output_vector(std::ostream &) const`
`public template<>` `inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(const S &,const std::string &) const`
`public template<>` `inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(const S &) const`
`public inline void` `operator<<(const` `SimpleObservableData< T > & obs)`
`public template<>` `inline const` `SimpleObservableEvaluator< T > &` `transform(OPV opv,const std::string &)`
`public inline void` `extract_timeseries(ODump & dump) const`
`public inline virtual void` `save(ODump & dump) const`
`public inline virtual void` `load(IDump & dump)`
`public inline virtual void` `save(hdf5::archive &) const`
`public inline virtual void` `load(hdf5::archive &)`
`public template<>` `inline void` `add_to(const X & x)`
`public template<>` `inline void` `subtract_from(const X & x)`
`public template<>` `inline void` `divide(const X & x)`
`public template<>` `inline void` `multiply_to(const X & x)`
`public inline virtual std::string` `evaluation_method(Target t) const`
`public inline virtual void` `merge(const` `Observable` `&)`
`public inline virtual bool` `can_merge() const`	can this observable be merged with one of the same type
`public inline virtual bool` `can_merge(const` `Observable` `&) const`	can this observable be merged with one of the given type
`public inline virtual` `Observable*convert_mergeable() const`	create a copy of the observable that can be merged
`public inline virtual` `SimpleObservableEvaluator< value_type >` `make_evaluator() const`
`enum` ``
`typedef` `value_type`
`typedef` `time_type`
`typedef` `result_type`
`typedef` `convergence_type`
`typedef` `label_type`
`typedef` `count_type`
`typedef` `covariance_type`

Members

`public inline virtual uint32_t` `version_id() const`

return a version ID uniquely identifying the class

`public inline` `SimpleObservableEvaluator(const std::string & n)`

almost default constructor

`public inline` `SimpleObservableEvaluator(const char * n)`

`public inline` `SimpleObservableEvaluator(const` `SimpleObservableEvaluator` `& eval)`

copy constructor

`public inline` `SimpleObservableEvaluator(const` `Observable` `& obs,const std::string & n)`

constructor from an observable

`public inline` `SimpleObservableEvaluator(const` `Observable` `& obs)`

`public inline` `SimpleObservableEvaluator(const std::string & n,std::istream &,const XMLTag &)`

`public inline const` `SimpleObservableEvaluator< T > &` `operator=(const` `SimpleObservableEvaluator< T > & eval)`

needed for silcing: assign an observable, replacing all observables in the class

`public inline const` `SimpleObservableEvaluator< T > &` `operator=(const` `AbstractSimpleObservable< T > & obs)`

`public inline` `SimpleObservableEvaluator< T > &` `operator<<(const` `AbstractSimpleObservable< T > & obs)`

add an observable to the ones already in the class

`public inline virtual void` `rename(const std::string &)`

rename the observable

`public inline void` `rename(const std::string & n,bool a)`

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

reset the observable

`public inline virtual bool` `has_tau() const`

is autocorrelation information available ?

`public inline virtual bool` `has_variance() const`

is variance available ?

`public inline result_type` `value() const`

`public inline virtual result_type` `mean() const`

the mean value

`public inline virtual result_type` `variance() const`

the variance

`public inline virtual result_type` `error() const`

the error

`public inline virtual convergence_type` `converged_errors() const`

`public inline virtual time_type` `tau() const`

the autocorrelation time, throws an exception if not available

`public inline covariance_type` `covariance(SimpleObservableEvaluator` `& obs2) const`

`public inline virtual count_type` `bin_number() const`

the number of bins

`public inline virtual const value_type &` `bin_value(count_type) const`

the value of a bin

`public inline virtual count_type` `bin_number2() const`

the number of bins with squared values

`public inline virtual const value_type &` `bin_value2(count_type) const`

the squared value of a bin

`public inline virtual count_type` `bin_size() const`

the number of measurements per bin

`public inline virtual count_type` `count() const`

the number of measurements

`public inline const std::vector< value_type > &` `bins() const`

`public inline virtual` `Observable*clone() const`

clones the observable

`public inline uint32_t` `get_thermalization() const`

`public inline bool` `can_set_thermalization() const`

`public inline ALPS_DUMMY_VOID` `compact()`

`public inline` `SimpleObservableEvaluator< T >` `operator-() const`

negate

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator+=(const X &)`

add a constant

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator-=(const X &)`

subtract a constant

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator*=(const X &)`

multiply with a constant

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator/=(const X &)`

divide by a constant

`public inline const` `SimpleObservableEvaluator< T > &` `operator+=(const` `SimpleObservableEvaluator< T > &)`

add another observable

`public inline const` `SimpleObservableEvaluator< T > &` `operator-=(const` `SimpleObservableEvaluator< T > &)`

subtract another observable

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator*=(const` `SimpleObservableEvaluator< X > &)`

multiply by another observable

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `operator/=(const` `SimpleObservableEvaluator< X > &)`

divide by another observable

`public virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

output the result

`public void` `output_scalar(std::ostream &) const`

`public void` `output_vector(std::ostream &) const`

`public template<>`
`inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(const S &,const std::string &) const`

`public template<>`
`inline` `SimpleObservableEvaluator< typename element_type< T >::type >` `slice(const S &) const`

`public inline void` `operator<<(const` `SimpleObservableData< T > & obs)`

`public template<>`
`inline const` `SimpleObservableEvaluator< T > &` `transform(OPV opv,const std::string &)`

`public inline void` `extract_timeseries(ODump & dump) const`

`public inline virtual void` `save(ODump & dump) const`

`public inline virtual void` `load(IDump & dump)`

`public inline virtual void` `save(hdf5::archive &) const`

`public inline virtual void` `load(hdf5::archive &)`

`public template<>`
`inline void` `add_to(const X & x)`

`public template<>`
`inline void` `subtract_from(const X & x)`

`public template<>`
`inline void` `divide(const X & x)`

`public template<>`
`inline void` `multiply_to(const X & x)`

`public inline virtual std::string` `evaluation_method(Target t) const`

`public inline virtual void` `merge(const` `Observable` `&)`

`public inline virtual bool` `can_merge() const`

can this observable be merged with one of the same type

`public inline virtual bool` `can_merge(const` `Observable` `&) const`

can this observable be merged with one of the given type

`public inline virtual` `Observable*convert_mergeable() const`

create a copy of the observable that can be merged

`public inline virtual` `SimpleObservableEvaluator< value_type >` `make_evaluator() const`

`enum` ``

Values	Descriptions
version

`typedef` `value_type`

`typedef` `time_type`

`typedef` `result_type`

`typedef` `convergence_type`

`typedef` `label_type`

`typedef` `count_type`

`typedef` `covariance_type`

struct `alps::ObservableNamingHelper`

Summary

Members	Descriptions

Members

struct `alps::output_helper`

Summary

Members	Descriptions

Members

struct `alps::output_helper< boost::mpl::false_ >`

Summary

Members	Descriptions

Members

struct `alps::output_helper< boost::mpl::true_ >`

Summary

Members	Descriptions

Members

struct `alps::type_tag< std::valarray< T > >`

struct alps::type_tag< std::valarray< T > >
  : public boost::mpl::int_< 256+type_tag< T >::value >

Summary

Members	Descriptions

Members

struct `alps::type_tag< std::vector< T > >`

struct alps::type_tag< std::vector< T > >
  : public boost::mpl::int_< 256+type_tag< T >::value >

Summary

Members	Descriptions

Members

namespace `alps::alea`

Summary

Members	Descriptions
`public template<>` `const_iterator_type< TimeseriesType >::type` `range_begin(const TimeseriesType & timeseries)`
`public template<>` `std::vector< ValueType >::const_iterator` `range_begin(const` `alps::alea::mcdata< ValueType > & timeseries)`
`public template<>` `const_iterator_type< TimeseriesType >::type` `range_end(const TimeseriesType & timeseries)`
`public template<>` `std::vector< ValueType >::const_iterator` `range_end(const` `alps::alea::mcdata< ValueType > & timeseries)`
`public template<>` `mctimeseries_view< typename TimeseriesType::value_type >` `cut_head_distance(const TimeseriesType & timeseries,int cutoff)`
`public template<>` `mctimeseries_view< typename TimeseriesType::value_type >` `cut_tail_distance(const TimeseriesType & timeseries,int cutoff)`
`public template<>` `mctimeseries_view< typename TimeseriesType::value_type >` `cut_head_limit(const TimeseriesType & timeseries,double limit)`
`public template<>` `mctimeseries_view< typename TimeseriesType::value_type >` `cut_tail_limit(const TimeseriesType & timeseries,double limit)`
`public template<>` `average_type< typenameTimeseriesType::value_type >::type` `mean(const TimeseriesType & timeseries)`
`public template<>` `average_type< typenameTimeseriesType::value_type >::type` `variance(const TimeseriesType & timeseries)`
`public template<>` `mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `autocorrelation_distance(const TimeseriesType & timeseries,int up_to)`
`public template<>` `mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `autocorrelation_limit(const TimeseriesType & timeseries,double limit)`
`public template<>` `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)`
`public template<>` `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)`
`public template<>` `average_type< typenameTimeseriesType::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)`
`public template<>` `average_type< typenameTimeseriesType::value_type >::type` `error(const TimeseriesType & timeseries,const` `uncorrelated_selector` `& selector)`
`public template<>` `average_type< typenameTimeseriesType::value_type >::type` `error(const TimeseriesType & timeseries,const` `binning_selector` `& selector)`
`public template<>` `inline average_type< typenameTimeseriesType::value_type >::type` `uncorrelated_error(const TimeseriesType & timeseries)`
`public template<>` `inline average_type< typenameTimeseriesType::value_type >::type` `binning_error(const TimeseriesType & timeseries)`
`public template<>` `mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `running_mean(const TimeseriesType & timeseries)`
`public template<>` `mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `reverse_running_mean(const TimeseriesType & timeseries)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,mcdata< T > const & obs)`
`public template<>` `inline` `mcdata< T >` `operator+(T const & arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< T >` `operator-(T const & arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< T >` `operator*(T const & arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< T >` `operator/(T const & arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator+(mcdata< std::vector< T > > arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator+(mcdata< T > arg1,mcdata< std::vector< T > > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator-(mcdata< std::vector< T > > arg1,mcdata< T > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator-(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator*(mcdata< std::vector< T > > arg1,mcdata< T > const & arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator*(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator/(mcdata< std::vector< T > > arg1,mcdata< T > const & arg2)`
`public template<>` `inline` `mcdata< std::vector< T > >` `operator/(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`
`public template<>` `mcdata< T >` `pow(mcdata< T > rhs,typename` `mcdata< T >::recursive_element_type exponent)`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sin,abs(cos(rhs.mean()) *rhs.error()))`
`public` `abs(- sin)`
`public` `abs(1./)`
`public` `abs(cosh(rhs.mean()) *rhs.error())`
`public` `abs(sinh(rhs.mean()) *rhs.error())`
`public` `abs(1./)`
`public` `abs(1./ sqrt)`
`public` `abs(-1./ sqrt)`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(atan,abs(1./(1.+rhs.mean() rhs.mean()) rhs.error()))`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(abs,rhs. error)`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sq,abs(2. rhs.mean() rhs.error()))`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cb,abs(3. sq(rhs.mean()) rhs.error()))`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sqrt,abs(rhs.error()/(2. *sqrt(rhs.mean()))))`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cbrt,abs(rhs.error()/(3. *sq(pow(rhs.mean(), 1./3)))))`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(exp,exp(rhs.mean()) *rhs.error())`
`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(log,abs(rhs.error()/rhs.mean()))`
`public template<>` `std::ostream &` `operator<<(std::ostream & out,value_with_error< T > const & value)`
`public template<>` `std::ostream &` `operator<<(std::ostream & out,value_with_error< std::vector< T > > const & vec)`
`public template<>` `inline` `value_with_error< T > &` `operator+(value_with_error< T > & rhs)`
`public template<>` `inline` `value_with_error< T >` `operator-(value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `abs(value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `operator+(T const & lhs,value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `operator-(T const & lhs,value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `operator*(T const & lhs,value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `operator/(T const & lhs,value_with_error< T > const & rhs)`
`public template<>` `inline` `value_with_error< T >` `pow(value_with_error< T > rhs,typename` `value_with_error< T >::element_type const & exponent)`
`public template<>` `inline` `value_with_error< T >` `sq(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `cb(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `sqrt(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `cbrt(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `exp(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `log(value_with_error< T > rhs)`
`public template<>` `inline` `value_with_error< T >` `sin(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `cos(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `tan(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `sinh(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `cosh(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `tanh(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `asin(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `acos(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `atan(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `asinh(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `acosh(value_with_error< T > rhs)`
`public template<>` `value_with_error< T >` `atanh(value_with_error< T > rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator+(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator+(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator-(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator-(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator*(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator*(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator/(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`
`public template<>` `inline std::vector<` `value_with_error< T > >` `operator/(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`
`public template<>` `inline std::vector< T >` `operator-(std::vector< T > const & rhs)`
`public template<>` `inline static std::vector<` `value_with_error< T > >` `vec_pow(std::vector<` `value_with_error< T > > const & rhs,T const & exponent)`
`public template<>` `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)`
`public template<>` `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)`
`class` `alps::alea::mcdata`
`class` `alps::alea::mctimeseries`
`class` `alps::alea::mctimeseries_view`
`class` `alps::alea::None_class`
`class` `alps::alea::NotEnoughMeasurementsError`
`class` `alps::alea::value_with_error`
`struct` `alps::alea::binning_selector`
`struct` `alps::alea::const_iterator_type`
`struct` `alps::alea::const_iterator_type< alps::alea::mcdata< ValueType > >`
`struct` `alps::alea::iterator_type`
`struct` `alps::alea::iterator_type< alps::alea::mcdata< ValueType > >`
`struct` `alps::alea::uncorrelated_selector`

Members

`public template<>`
`const_iterator_type< TimeseriesType >::type` `range_begin(const TimeseriesType & timeseries)`

`public template<>`
`std::vector< ValueType >::const_iterator` `range_begin(const` `alps::alea::mcdata< ValueType > & timeseries)`

`public template<>`
`const_iterator_type< TimeseriesType >::type` `range_end(const TimeseriesType & timeseries)`

`public template<>`
`std::vector< ValueType >::const_iterator` `range_end(const` `alps::alea::mcdata< ValueType > & timeseries)`

`public template<>`
`mctimeseries_view< typename TimeseriesType::value_type >` `cut_head_distance(const TimeseriesType & timeseries,int cutoff)`

`public template<>`
`mctimeseries_view< typename TimeseriesType::value_type >` `cut_tail_distance(const TimeseriesType & timeseries,int cutoff)`

`public template<>`
`mctimeseries_view< typename TimeseriesType::value_type >` `cut_head_limit(const TimeseriesType & timeseries,double limit)`

`public template<>`
`mctimeseries_view< typename TimeseriesType::value_type >` `cut_tail_limit(const TimeseriesType & timeseries,double limit)`

`public template<>`
`average_type< typenameTimeseriesType::value_type >::type` `mean(const TimeseriesType & timeseries)`

`public template<>`
`average_type< typenameTimeseriesType::value_type >::type` `variance(const TimeseriesType & timeseries)`

`public template<>`
`mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `autocorrelation_distance(const TimeseriesType & timeseries,int up_to)`

`public template<>`
`mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `autocorrelation_limit(const TimeseriesType & timeseries,double limit)`

`public template<>`
`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)`

`public template<>`
`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)`

`public template<>`
`average_type< typenameTimeseriesType::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)`

`public template<>`
`average_type< typenameTimeseriesType::value_type >::type` `error(const TimeseriesType & timeseries,const` `uncorrelated_selector` `& selector)`

`public template<>`
`average_type< typenameTimeseriesType::value_type >::type` `error(const TimeseriesType & timeseries,const` `binning_selector` `& selector)`

`public template<>`
`inline average_type< typenameTimeseriesType::value_type >::type` `uncorrelated_error(const TimeseriesType & timeseries)`

`public template<>`
`inline average_type< typenameTimeseriesType::value_type >::type` `binning_error(const TimeseriesType & timeseries)`

`public template<>`
`mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `running_mean(const TimeseriesType & timeseries)`

`public template<>`
`mctimeseries< typename average_type< typename TimeseriesType::value_type >::type >` `reverse_running_mean(const TimeseriesType & timeseries)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,mcdata< T > const & obs)`

`public template<>`
`inline` `mcdata< T >` `operator+(T const & arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< T >` `operator-(T const & arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< T >` `operator*(T const & arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< T >` `operator/(T const & arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator+(mcdata< std::vector< T > > arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator+(mcdata< T > arg1,mcdata< std::vector< T > > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator-(mcdata< std::vector< T > > arg1,mcdata< T > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator-(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator*(mcdata< std::vector< T > > arg1,mcdata< T > const & arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator*(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator/(mcdata< std::vector< T > > arg1,mcdata< T > const & arg2)`

`public template<>`
`inline` `mcdata< std::vector< T > >` `operator/(mcdata< T > const & arg1,mcdata< std::vector< T > > arg2)`

`public template<>`
`mcdata< T >` `pow(mcdata< T > rhs,typename` `mcdata< T >::recursive_element_type exponent)`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sin,abs(cos(rhs.mean()) *rhs.error()))`

`public` `abs(- sin)`

`public` `abs(1./)`

`public` `abs(cosh(rhs.mean()) *rhs.error())`

`public` `abs(sinh(rhs.mean()) *rhs.error())`

`public` `abs(1./)`

`public` `abs(1./ sqrt)`

`public` `abs(-1./ sqrt)`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(atan,abs(1./(1.+rhs.mean() rhs.mean()) rhs.error()))`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(abs,rhs. error)`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sq,abs(2. rhs.mean() rhs.error()))`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cb,abs(3. sq(rhs.mean()) rhs.error()))`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sqrt,abs(rhs.error()/(2. *sqrt(rhs.mean()))))`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cbrt,abs(rhs.error()/(3. *sq(pow(rhs.mean(), 1./3)))))`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(exp,exp(rhs.mean()) *rhs.error())`

`public` `ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(log,abs(rhs.error()/rhs.mean()))`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,value_with_error< T > const & value)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,value_with_error< std::vector< T > > const & vec)`

`public template<>`
`inline` `value_with_error< T > &` `operator+(value_with_error< T > & rhs)`

`public template<>`
`inline` `value_with_error< T >` `operator-(value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `abs(value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `operator+(T const & lhs,value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `operator-(T const & lhs,value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `operator*(T const & lhs,value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `operator/(T const & lhs,value_with_error< T > const & rhs)`

`public template<>`
`inline` `value_with_error< T >` `pow(value_with_error< T > rhs,typename` `value_with_error< T >::element_type const & exponent)`

`public template<>`
`inline` `value_with_error< T >` `sq(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `cb(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `sqrt(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `cbrt(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `exp(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `log(value_with_error< T > rhs)`

`public template<>`
`inline` `value_with_error< T >` `sin(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `cos(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `tan(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `sinh(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `cosh(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `tanh(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `asin(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `acos(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `atan(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `asinh(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `acosh(value_with_error< T > rhs)`

`public template<>`
`value_with_error< T >` `atanh(value_with_error< T > rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator+(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator+(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator+(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator-(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator-(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator-(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator*(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator*(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator*(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,T const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator/(T const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator/(std::vector<` `value_with_error< T > > const & lhs,std::vector< T > const & rhs)`

`public template<>`
`inline std::vector<` `value_with_error< T > >` `operator/(std::vector< T > const & lhs,std::vector<` `value_with_error< T > > const & rhs)`

`public template<>`
`inline std::vector< T >` `operator-(std::vector< T > const & rhs)`

`public template<>`
`inline static std::vector<` `value_with_error< T > >` `vec_pow(std::vector<` `value_with_error< T > > const & rhs,T const & exponent)`

`public template<>`
`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)`

`public template<>`
`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)`

class `alps::alea::mcdata`

Summary

Members	Descriptions
`public inline` `mcdata()`
`public inline` `mcdata(result_type mean,result_type error)`
`public inline std::size_t` `size() const`
`public template<>` `inline` `mcdata(mcdata< X > const & rhs,S s)`
`public template<>` `inline` `mcdata(mcdata< X > const & rhs,S from,S to)`
`public template<>` `inline` `mcdata(AbstractSimpleObservable< X > const & obs)`
`public inline` `const_iterator` `begin() const`
`public inline` `const_iterator` `end() const`
`public inline bool` `can_rebin() const`
`public inline bool` `jackknife_valid() const`
`public inline void` `swap(mcdata< T > & rhs)`
`public inline uint64_t` `count() const`
`public inline uint64_t` `bin_size() const`
`public inline uint64_t` `max_bin_number() const`
`public inline std::size_t` `bin_number() const`
`public inline std::vector< value_type > const &` `bins() const`
`public inline std::vector< result_type > const &` `jackknife() const`
`public inline result_type const &` `mean() const`
`public inline result_type const &` `error() const`
`public inline bool` `has_variance() const`
`public inline result_type const &` `variance() const`
`public inline bool` `has_tau() const`
`public inline time_type const &` `tau() const`
`public inline covariance_type` `covariance(mcdata< T > const & obs) const`
`public inline covariance_type` `accurate_covariance(mcdata< T > const & obs) const`
`public inline void` `set_bin_size(uint64_t binsize)`
`public inline void` `set_bin_number(uint64_t bin_number)`
`public inline void` `discard_bins(size_type keep_bins)`
`public inline void` `output(std::ostream & out) const`
`public inline void` `save(hdf5::archive & ar) const`
`public inline void` `load(hdf5::archive & ar)`
`public inline void` `save(std::string const & filename,std::string const & path) const`
`public inline void` `load(std::string const & filename,std::string const & path)`
`public inline void` `merge(mcdata< T > const & rhs)`
`public inline` `mcdata< T > &` `operator<<(mcdata< T > const & rhs)`
`public inline` `mcdata< T > &` `operator=(mcdata< T > rhs)`
`public template<>` `inline element_type` `slice(S s) const`
`public template<>` `inline bool` `operator==(mcdata< X > const & rhs) const`
`public template<>` `inline bool` `operator==(mcdata< std::vector< X > > const & rhs) const`
`public template<>` `inline bool` `operator!=(mcdata< X > const & rhs) const`
`public inline` `mcdata< T > &` `operator+=(mcdata< T > const & rhs)`
`public inline` `mcdata< T > &` `operator-=(mcdata< T > const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator*=(mcdata< X > const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator/=(mcdata< X > const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator+=(X const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator-=(X const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator*=(X const & rhs)`
`public template<>` `inline` `mcdata< T > &` `operator/=(X const & rhs)`
`public inline` `mcdata< T > &` `operator+()`
`public inline` `mcdata< T > &` `operator-()`
`public template<>` `inline void` `subtract_from(X const & x)`
`public template<>` `inline void` `divide(X const & x)`
`public template<>` `inline void` `transform_linear(OP op,value_type const & error,boost::optional< result_type > variance_opt)`
`public template<>` `inline void` `transform(OP op,value_type const & error,boost::optional< result_type > variance_opt)`
`public template<>` `inline void` `transform(mcdata< X > const & rhs,OP op,value_type const & error,boost::optional< result_type > variance_opt)`
`protected inline` `mcdata(int64_t count,value_type const & mean,value_type const & error,boost::optional< result_type > const & variance_opt,boost::optional< time_type > const & tau_opt,uint64_t binsize,uint64_t max_bin_number,std::vector< value_type > const & values)`
`typedef` `value_type`
`typedef` `recursive_element_type`
`typedef` `element_type`
`typedef` `time_type`
`typedef` `size_type`
`typedef` `count_type`
`typedef` `result_type`
`typedef` `convergence_type`
`typedef` `covariance_type`

Members

`public inline` `mcdata()`

`public inline` `mcdata(result_type mean,result_type error)`

`public inline std::size_t` `size() const`

`public template<>`
`inline` `mcdata(mcdata< X > const & rhs,S s)`

`public template<>`
`inline` `mcdata(mcdata< X > const & rhs,S from,S to)`

`public template<>`
`inline` `mcdata(AbstractSimpleObservable< X > const & obs)`

`public inline` `const_iterator` `begin() const`

`public inline` `const_iterator` `end() const`

`public inline bool` `can_rebin() const`

`public inline bool` `jackknife_valid() const`

`public inline void` `swap(mcdata< T > & rhs)`

`public inline uint64_t` `count() const`

`public inline uint64_t` `bin_size() const`

`public inline uint64_t` `max_bin_number() const`

`public inline std::size_t` `bin_number() const`

`public inline std::vector< value_type > const &` `bins() const`

`public inline std::vector< result_type > const &` `jackknife() const`

`public inline result_type const &` `mean() const`

`public inline result_type const &` `error() const`

`public inline bool` `has_variance() const`

`public inline result_type const &` `variance() const`

`public inline bool` `has_tau() const`

`public inline time_type const &` `tau() const`

`public inline covariance_type` `covariance(mcdata< T > const & obs) const`

`public inline covariance_type` `accurate_covariance(mcdata< T > const & obs) const`

`public inline void` `set_bin_size(uint64_t binsize)`

`public inline void` `set_bin_number(uint64_t bin_number)`

`public inline void` `discard_bins(size_type keep_bins)`

`public inline void` `output(std::ostream & out) const`

`public inline void` `save(hdf5::archive & ar) const`

`public inline void` `load(hdf5::archive & ar)`

`public inline void` `save(std::string const & filename,std::string const & path) const`

`public inline void` `load(std::string const & filename,std::string const & path)`

`public inline void` `merge(mcdata< T > const & rhs)`

`public inline` `mcdata< T > &` `operator<<(mcdata< T > const & rhs)`

`public inline` `mcdata< T > &` `operator=(mcdata< T > rhs)`

`public template<>`
`inline element_type` `slice(S s) const`

`public template<>`
`inline bool` `operator==(mcdata< X > const & rhs) const`

`public template<>`
`inline bool` `operator==(mcdata< std::vector< X > > const & rhs) const`

`public template<>`
`inline bool` `operator!=(mcdata< X > const & rhs) const`

`public inline` `mcdata< T > &` `operator+=(mcdata< T > const & rhs)`

`public inline` `mcdata< T > &` `operator-=(mcdata< T > const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator*=(mcdata< X > const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator/=(mcdata< X > const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator+=(X const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator-=(X const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator*=(X const & rhs)`

`public template<>`
`inline` `mcdata< T > &` `operator/=(X const & rhs)`

`public inline` `mcdata< T > &` `operator+()`

`public inline` `mcdata< T > &` `operator-()`

`public template<>`
`inline void` `subtract_from(X const & x)`

`public template<>`
`inline void` `divide(X const & x)`

`public template<>`
`inline void` `transform_linear(OP op,value_type const & error,boost::optional< result_type > variance_opt)`

`public template<>`
`inline void` `transform(OP op,value_type const & error,boost::optional< result_type > variance_opt)`

`public template<>`
`inline void` `transform(mcdata< X > const & rhs,OP op,value_type const & error,boost::optional< result_type > variance_opt)`

`protected inline` `mcdata(int64_t count,value_type const & mean,value_type const & error,boost::optional< result_type > const & variance_opt,boost::optional< time_type > const & tau_opt,uint64_t binsize,uint64_t max_bin_number,std::vector< value_type > const & values)`

`typedef` `value_type`

`typedef` `recursive_element_type`

`typedef` `element_type`

`typedef` `time_type`

`typedef` `size_type`

`typedef` `count_type`

`typedef` `result_type`

`typedef` `convergence_type`

`typedef` `covariance_type`

class `alps::alea::mctimeseries`

Summary

Members	Descriptions
`public inline` `mctimeseries()`
`public inline` `mctimeseries(const` `alps::alea::mcdata< ValueType > & IN)`
`public inline` `mctimeseries(const` `alps::alea::mctimeseries< ValueType > & IN)`
`public inline` `mctimeseries(const` `alps::alea::mctimeseries_view< ValueType > & IN)`
`public inline` `mctimeseries(const std::vector< ValueType > & timeseries)`
`public inline void` `shallow_assign(const` `mctimeseries< ValueType > & IN)`
`public inline const_iterator` `begin() const`
`public inline const_iterator` `end() const`
`public inline iterator` `begin()`
`public inline iterator` `end()`
`public inline std::size_t` `size() const`
`public inline void` `push_back(value_type IN)`
`public inline void` `resize(std::size_t size)`
`public inline std::vector< ValueType >` `timeseries() const`
`public inline void` `print() const`
`typedef` `size_type`
`typedef` `value_type`
`typedef` `average_type`
`typedef` `iterator`
`typedef` `const_iterator`

Members

`public inline` `mctimeseries()`

`public inline` `mctimeseries(const` `alps::alea::mcdata< ValueType > & IN)`

`public inline` `mctimeseries(const` `alps::alea::mctimeseries< ValueType > & IN)`

`public inline` `mctimeseries(const` `alps::alea::mctimeseries_view< ValueType > & IN)`

`public inline` `mctimeseries(const std::vector< ValueType > & timeseries)`

`public inline void` `shallow_assign(const` `mctimeseries< ValueType > & IN)`

`public inline const_iterator` `begin() const`

`public inline const_iterator` `end() const`

`public inline iterator` `begin()`

`public inline iterator` `end()`

`public inline std::size_t` `size() const`

`public inline void` `push_back(value_type IN)`

`public inline void` `resize(std::size_t size)`

`public inline std::vector< ValueType >` `timeseries() const`

`public inline void` `print() const`

`typedef` `size_type`

`typedef` `value_type`

`typedef` `average_type`

`typedef` `iterator`

`typedef` `const_iterator`

class `alps::alea::mctimeseries_view`

Summary

Members	Descriptions
`public inline` `mctimeseries_view(const` `mctimeseries< ValueType > & timeseries)`
`public inline void` `cut_head(int cutoff)`
`public inline void` `cut_tail(int cutoff)`
`public inline const_iterator` `begin() const`
`public inline const_iterator` `end() const`
`public inline std::size_t` `size() const`
`public inline std::vector< ValueType >` `timeseries() const`
`public inline void` `print() const`
`typedef` `size_type`
`typedef` `value_type`
`typedef` `average_type`
`typedef` `iterator`
`typedef` `const_iterator`

Members

`public inline` `mctimeseries_view(const` `mctimeseries< ValueType > & timeseries)`

`public inline void` `cut_head(int cutoff)`

`public inline void` `cut_tail(int cutoff)`

`public inline const_iterator` `begin() const`

`public inline const_iterator` `end() const`

`public inline std::size_t` `size() const`

`public inline std::vector< ValueType >` `timeseries() const`

`public inline void` `print() const`

`typedef` `size_type`

`typedef` `value_type`

`typedef` `average_type`

`typedef` `iterator`

`typedef` `const_iterator`

class `alps::alea::None_class`

Summary

Members	Descriptions
`public inline` `None_class()`
`public inline` `None_class(const` `None_class` `& other)`
`public template<>` `inline` `None_class(const T &)`
`public inline bool` `operator==(const` `None_class` `& other) const`
`public inline bool` `operator!=(const` `None_class` `& other) const`
`public inline` `operator int()`

Members

`public inline` `None_class()`

`public inline` `None_class(const` `None_class` `& other)`

`public template<>`
`inline` `None_class(const T &)`

`public inline bool` `operator==(const` `None_class` `& other) const`

`public inline bool` `operator!=(const` `None_class` `& other) const`

`public inline` `operator int()`

class `alps::alea::NotEnoughMeasurementsError`

class alps::alea::NotEnoughMeasurementsError
  : public std::runtime_error

Summary

Members	Descriptions
`public inline` `NotEnoughMeasurementsError()`

Members

`public inline` `NotEnoughMeasurementsError()`

class `alps::alea::value_with_error`

Summary

Members	Descriptions
`public inline` `value_with_error(value_type mean,value_type error)`
`public inline` `value_with_error< value_type > &` `operator=(value_with_error< value_type > const rhs)`
`public inline value_type` `mean() const`
`public inline value_type` `error() const`
`public inline bool` `operator==(value_with_error` `const & rhs)`
`public inline` `value_with_error< value_type > &` `operator+=(value_with_error< value_type > const & rhs)`
`public inline` `value_with_error< value_type > &` `operator+=(value_type const & rhs)`
`public inline` `value_with_error< value_type > &` `operator-=(value_with_error` `const & rhs)`
`public inline` `value_with_error< value_type > &` `operator-=(value_type const & rhs)`
`public inline` `value_with_error< value_type > &` `operator*=(value_with_error< value_type > const & rhs)`
`public inline` `value_with_error< value_type > &` `operator*=(value_type const & rhs)`
`public inline` `value_with_error< value_type > &` `operator/=(value_with_error< value_type > const & rhs)`
`public inline` `value_with_error< value_type > &` `operator/=(value_type const & rhs)`
`public inline size_type` `size() const`
`public inline void` `push_back(value_with_error< element_type > const & rhs)`
`public inline void` `pop_back()`
`public inline void` `clear()`
`public inline void` `insert(index_type const & index,value_with_error< element_type > const & value)`
`public inline void` `erase(index_type const & index)`
`public inline` `value_with_error< element_type >` `at(index_type const & index)`
`typedef` `value_type`
`typedef` `element_type`
`typedef` `size_type`
`typedef` `index_type`
`typedef` `difference_type`

Members

`public inline` `value_with_error(value_type mean,value_type error)`

`public inline` `value_with_error< value_type > &` `operator=(value_with_error< value_type > const rhs)`

`public inline value_type` `mean() const`

`public inline value_type` `error() const`

`public inline bool` `operator==(value_with_error` `const & rhs)`

`public inline` `value_with_error< value_type > &` `operator+=(value_with_error< value_type > const & rhs)`

`public inline` `value_with_error< value_type > &` `operator+=(value_type const & rhs)`

`public inline` `value_with_error< value_type > &` `operator-=(value_with_error` `const & rhs)`

`public inline` `value_with_error< value_type > &` `operator-=(value_type const & rhs)`

`public inline` `value_with_error< value_type > &` `operator*=(value_with_error< value_type > const & rhs)`

`public inline` `value_with_error< value_type > &` `operator*=(value_type const & rhs)`

`public inline` `value_with_error< value_type > &` `operator/=(value_with_error< value_type > const & rhs)`

`public inline` `value_with_error< value_type > &` `operator/=(value_type const & rhs)`

`public inline size_type` `size() const`

`public inline void` `push_back(value_with_error< element_type > const & rhs)`

`public inline void` `pop_back()`

`public inline void` `clear()`

`public inline void` `insert(index_type const & index,value_with_error< element_type > const & value)`

`public inline void` `erase(index_type const & index)`

`public inline` `value_with_error< element_type >` `at(index_type const & index)`

`typedef` `value_type`

`typedef` `element_type`

`typedef` `size_type`

`typedef` `index_type`

`typedef` `difference_type`

struct `alps::alea::binning_selector`

Summary

Members	Descriptions

Members

struct `alps::alea::const_iterator_type`

Summary

Members	Descriptions
`typedef` `type`

Members

`typedef` `type`

struct `alps::alea::const_iterator_type< alps::alea::mcdata< ValueType > >`

Summary

Members	Descriptions
`typedef` `type`

Members

`typedef` `type`

struct `alps::alea::iterator_type`

Summary

Members	Descriptions
`typedef` `type`

Members

`typedef` `type`

struct `alps::alea::iterator_type< alps::alea::mcdata< ValueType > >`

Summary

Members	Descriptions
`typedef` `type`

Members

`typedef` `type`

struct `alps::alea::uncorrelated_selector`

Summary

Members	Descriptions

Members

namespace `alps::detail`

Summary

Members	Descriptions
`public inline void` `deleteit(Observable` `& obs)`
`struct` `alps::detail::function_pow`
`struct` `alps::detail::input_helper`
`struct` `alps::detail::input_helper< boost::mpl::false_ >`
`struct` `alps::detail::input_helper< boost::mpl::true_ >`
`struct` `alps::detail::pick_add_merge`
`struct` `alps::detail::pick_add_merge< false >`
`struct` `alps::detail::pick_add_merge< true >`

Members

`public inline void` `deleteit(Observable` `& obs)`

struct `alps::detail::function_pow`

struct alps::detail::function_pow
  : public std::unary_function< T, double >

Summary

Members	Descriptions
`public double` `pow_`
`public inline` `function_pow(double p)`
`public inline T` `operator()(T x) const`

Members

`public double` `pow_`

`public inline` `function_pow(double p)`

`public inline T` `operator()(T x) const`

struct `alps::detail::input_helper`

Summary

Members	Descriptions

Members

struct `alps::detail::input_helper< boost::mpl::false_ >`

Summary

Members	Descriptions

Members

struct `alps::detail::input_helper< boost::mpl::true_ >`

Summary

Members	Descriptions

Members

struct `alps::detail::pick_add_merge`

Summary

Members	Descriptions

Members

struct `alps::detail::pick_add_merge< false >`

Summary

Members	Descriptions

Members

struct `alps::detail::pick_add_merge< true >`

Summary

Members	Descriptions

Members

class `alps::alea::mcdata::const_iterator`

class alps::alea::mcdata::const_iterator
  : public boost::random_access_iterator_helper< const_iterator, mcdata< T::value_type >, std::ptrdiff_t, mcdata< T::value_type > *, mcdata< T::value_type > & >

Summary

Members	Descriptions
`public inline` `const_iterator()`
`public inline` `const_iterator(mcdata< T > const & data,std::size_t index)`
`public inline` `const_iterator(const_iterator` `const & it)`
`public inline` `mcdata< typename T::value_type >` `operator*() const`
`public inline` `const_iterator&operator=(const_iterator` `const & rhs)`
`public inline void` `operator++()`
`public inline bool` `operator==(const_iterator` `const & rhs) const`
`public inline` `const_iterator&operator+=(std::ptrdiff_t n)`
`public inline bool` `operator<(const_iterator` `const & rhs) const`
`public inline std::ptrdiff_t` `operator-(const_iterator` `const & rhs)`

Members

`public inline` `const_iterator()`

`public inline` `const_iterator(mcdata< T > const & data,std::size_t index)`

`public inline` `const_iterator(const_iterator` `const & it)`

`public inline` `mcdata< typename T::value_type >` `operator*() const`

`public inline` `const_iterator&operator=(const_iterator` `const & rhs)`

`public inline void` `operator++()`

`public inline bool` `operator==(const_iterator` `const & rhs) const`

`public inline` `const_iterator&operator+=(std::ptrdiff_t n)`

`public inline bool` `operator<(const_iterator` `const & rhs) const`

`public inline std::ptrdiff_t` `operator-(const_iterator` `const & rhs)`

Generated by Moxygen

Analyzing Monte-Carlo data

Reference

Summary

namespace alps

Summary

Members

enum error_convergence

enum Target

public template<>inline bool error_underflow(T mean,T error)

public template<>inline bool error_underflow(std::complex< T > mean,std::complex< T > error)

public template<>inline std::string convergence_to_text(T)

public inline std::string convergence_to_text(int c)

public double nan()

public double inf()

public double ninf()

public inline std::ostream & operator<<(std::ostream & out,const alps::Observable & m)

public inline std::ostream & operator<<(std::ostream & out,const alps::ObservableSet & obs)

public template<>boost::shared_ptr< Observable>make_observable(const OBS & obs,bool issigned)

public template<>boost::shared_ptr< Observable>make_observable(const OBS & obs,const std::string & s,SIGN,bool issigned)

public inline double text_to_double(const std::string & val)

public template<>hdf5::archive & operator<<(hdf5::archive & ar,SimpleObservable< T, BINNING > const & obs)

public template<>hdf5::archive & operator>>(hdf5::archive & ar,SimpleObservable< T, BINNING > & obs)

public template<>inline alps::SimpleObservableEvaluator< T > operator+(alps::SimpleObservableEvaluator< T > const & x,const alps::SimpleObservableEvaluator< U > & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator+(alps::SimpleObservableEvaluator< T > const & x,const Y & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator+(const Y & y,alps::SimpleObservableEvaluator< T > const & x)

public template<>inline alps::SimpleObservableEvaluator< T > operator-(const alps::SimpleObservableEvaluator< T > & x,const alps::SimpleObservableEvaluator< U > & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator-(alps::SimpleObservableEvaluator< T > const & x,const Y & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator-(const Y & y,alps::SimpleObservableEvaluator< T > const & x)

public template<>inline alps::SimpleObservableEvaluator< T > operator*(const alps::SimpleObservableEvaluator< T > & x,const alps::SimpleObservableEvaluator< U > & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator*(alps::SimpleObservableEvaluator< T > const & x,const Y & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator*(const Y & y,alps::SimpleObservableEvaluator< T > const & x)

public template<>inline alps::SimpleObservableEvaluator< std::valarray< T > > operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x,const alps::SimpleObservableEvaluator< T > & y)

public template<>inline alps::SimpleObservableEvaluator< std::valarray< T > > operator*(const alps::SimpleObservableEvaluator< T > & y,alps::SimpleObservableEvaluator< std::valarray< T > > const & x)

public template<>inline alps::SimpleObservableEvaluator< T > operator/(const alps::SimpleObservableEvaluator< T > & x,const alps::SimpleObservableEvaluator< U > & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator/(alps::SimpleObservableEvaluator< T > const & x,const Y & y)

public template<>inline alps::SimpleObservableEvaluator< T > operator/(const Y & x,alps::SimpleObservableEvaluator< T > const & y)

public template<>alps::SimpleObservableEvaluator< T > pow(const alps::SimpleObservableEvaluator< T > & x,double p)

public template<>alps::SimpleObservableEvaluator< T > pow(const alps::SimpleObservableEvaluator< T > & x,int p)

class alps::A

Summary

Members

class alps::AbstractBinning

Summary

Members

public inline AbstractBinning(std::size_t)

public inline time_type tau() const

public inline uint32_t max_bin_number() const

public inline uint32_t bin_number() const

public inline uint32_t filled_bin_number() const

public inline uint32_t filled_bin_number2() const

public inline uint32_t bin_size() const

public inline const value_type & bin_value(uint32_t) const

public inline const value_type & bin_value2(uint32_t) const

public inline const std::vector< value_type > & bins() const

public inline void extract_timeseries(ODump & dump) const

public inline bool has_variance() const

public inline void write_scalar_xml(oxstream &) const

public template<>inline void write_vector_xml(oxstream &,IT) const

public inline void save(ODump &) const

public inline void load(IDump & dump)

public inline void save(hdf5::archive &) const

public inline void load(hdf5::archive &)

public inline std::string evaluation_method() const

typedef value_type

typedef time_type

typedef convergence_type

class alps::AbstractSignedObservable

Summary

Members

public BOOST_STATIC_CONSTANT(int,version)

public inline AbstractSignedObservable(const OBS & obs,const std::string & s)

public inline AbstractSignedObservable(const std::string & name,const std::string & s,const label_type & l)

public inline AbstractSignedObservable(const std::string & name,const char * s,const label_type & l)

public template<>inline AbstractSignedObservable(const AbstractSignedObservable< OBS2, SIGN > & o)

public template<>inline AbstractSignedObservable(const std::string & name,const ARG & arg,const label_type & l)

public template<>inline AbstractSignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)

public inline ~AbstractSignedObservable()

public inline virtual uint32_t version_id() const

public inline virtual ALPS_DUMMY_VOID reset(bool equilibrated)

public inline virtual ALPS_DUMMY_VOID output(std::ostream &) const

public void output_scalar(std::ostream &) const

namespace `alps`

`enum` `error_convergence`

`enum` `Target`

`public template<>`
`inline bool` `error_underflow(T mean,T error)`

`public template<>`
`inline bool` `error_underflow(std::complex< T > mean,std::complex< T > error)`

`public template<>`
`inline std::string` `convergence_to_text(T)`

`public inline std::string` `convergence_to_text(int c)`

`public double` `nan()`

`public double` `inf()`

`public double` `ninf()`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::Observable` `& m)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::ObservableSet` `& obs)`

`public template<>`
`boost::shared_ptr<` `Observable>make_observable(const OBS & obs,bool issigned)`

`public template<>`
`boost::shared_ptr<` `Observable>make_observable(const OBS & obs,const std::string & s,SIGN,bool issigned)`

`public inline double` `text_to_double(const std::string & val)`

`public template<>`
`hdf5::archive &` `operator<<(hdf5::archive & ar,SimpleObservable< T, BINNING > const & obs)`

`public template<>`
`hdf5::archive &` `operator>>(hdf5::archive & ar,SimpleObservable< T, BINNING > & obs)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const` `alps::SimpleObservableEvaluator< U > & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator+(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator-(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator*(const Y & y,alps::SimpleObservableEvaluator< T > const & x)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x,const` `alps::SimpleObservableEvaluator< T > & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< std::valarray< T > >` `operator*(const` `alps::SimpleObservableEvaluator< T > & y,alps::SimpleObservableEvaluator< std::valarray< T > > const & x)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(const` `alps::SimpleObservableEvaluator< T > & x,const` `alps::SimpleObservableEvaluator< U > & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(alps::SimpleObservableEvaluator< T > const & x,const Y & y)`

`public template<>`
`inline` `alps::SimpleObservableEvaluator< T >` `operator/(const Y & x,alps::SimpleObservableEvaluator< T > const & y)`

`public template<>`
`alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,double p)`

`public template<>`
`alps::SimpleObservableEvaluator< T >` `pow(const` `alps::SimpleObservableEvaluator< T > & x,int p)`

class `alps::A`

class `alps::AbstractBinning`

`public inline` `AbstractBinning(std::size_t)`

`public inline time_type` `tau() const`

`public inline uint32_t` `max_bin_number() const`

`public inline uint32_t` `bin_number() const`

`public inline uint32_t` `filled_bin_number() const`

`public inline uint32_t` `filled_bin_number2() const`

`public inline uint32_t` `bin_size() const`

`public inline const value_type &` `bin_value(uint32_t) const`

`public inline const value_type &` `bin_value2(uint32_t) const`

`public inline const std::vector< value_type > &` `bins() const`

`public inline void` `extract_timeseries(ODump & dump) const`

`public inline bool` `has_variance() const`

`public inline void` `write_scalar_xml(oxstream &) const`

`public template<>`
`inline void` `write_vector_xml(oxstream &,IT) const`

`public inline void` `save(ODump &) const`

`public inline void` `load(IDump & dump)`

`public inline void` `save(hdf5::archive &) const`

`public inline void` `load(hdf5::archive &)`

`public inline std::string` `evaluation_method() const`

`typedef` `value_type`

`typedef` `time_type`

`typedef` `convergence_type`

class `alps::AbstractSignedObservable`

`public` `BOOST_STATIC_CONSTANT(int,version)`

`public inline` `AbstractSignedObservable(const OBS & obs,const std::string & s)`

`public inline` `AbstractSignedObservable(const std::string & name,const std::string & s,const label_type & l)`

`public inline` `AbstractSignedObservable(const std::string & name,const char * s,const label_type & l)`

`public template<>`
`inline` `AbstractSignedObservable(const` `AbstractSignedObservable< OBS2, SIGN > & o)`

`public template<>`
`inline` `AbstractSignedObservable(const std::string & name,const ARG & arg,const label_type & l)`

`public template<>`
`inline` `AbstractSignedObservable(const std::string & name,std::string & s,const ARG & arg,const label_type & l)`

`public inline` `~AbstractSignedObservable()`

`public inline virtual uint32_t` `version_id() const`

`public inline virtual ALPS_DUMMY_VOID` `reset(bool equilibrated)`

`public inline virtual ALPS_DUMMY_VOID` `output(std::ostream &) const`

`public void` `output_scalar(std::ostream &) const`

`public void` `output_vector(std::ostream &) const`

`public inline virtual void` `write_xml(oxstream & oxs,const boost::filesystem::path & fn_hdf5) const`

`public inline virtual count_type` `count() const`

`public inline virtual result_type` `mean() const`

`public inline virtual result_type` `error() const`

`public inline virtual convergence_type` `converged_errors() const`

`public inline virtual` `SimpleObservableEvaluator< value_type >` `make_evaluator() const`

`public template<>`
`inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `slice(S s,const std::string & newname) const`

`public template<>`
`inline` `AbstractSignedObservable](#d9/d7a/classalps_1_1_abstract_signed_observable)< [SimpleObservableEvaluator< typename element_type< value_type >::type >, SIGN >` `operator[](S s) const`

`public virtual void` `save(ODump & dump) const`