ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Class template SimpleObservableEvaluator

alps::SimpleObservableEvaluator

Synopsis

// In header: <alps/alea/simpleobseval.h>

template<typename T> 
class SimpleObservableEvaluator : public alps::AbstractSimpleObservable< T > {
public:
  // types
  typedef T                                          value_type;        // the data type of the observable 
  typedef change_value_type< T, double >::type       time_type;         // the data type for autocorrelation times 
  typedef AbstractSimpleObservable< T >::result_type result_type;       // the data type of averages and errors 
  typedef change_value_type< T, int >::type          convergence_type;
  typedef AbstractSimpleObservable< T >::label_type  label_type;      
  typedef uint64_t                                   count_type;        // the count data type: an integral type 
  typedef SimpleObservableData< T >::covariance_type covariance_type; 

  enum @0 { version =  type_tag<T>::value + (6 << 16) };

  // construct/copy/destruct
  SimpleObservableEvaluator(const std::string & = "");
  SimpleObservableEvaluator(const char *);
  SimpleObservableEvaluator(const SimpleObservableEvaluator &);
  SimpleObservableEvaluator(const Observable &, const std::string &);
  SimpleObservableEvaluator(const Observable &);
  SimpleObservableEvaluator(const std::string &, std::istream &, 
                            const XMLTag &);
  SimpleObservableEvaluator& operator=(const SimpleObservableEvaluator< T > &);
  SimpleObservableEvaluator& operator=(const AbstractSimpleObservable< T > &);

  // public member functions
  uint32_t version_id() const;
  SimpleObservableEvaluator< T > & 
  operator<<(const AbstractSimpleObservable< T > &);
  void rename(const std::string &);
  void rename(const std::string &, bool);
  ALPS_DUMMY_VOID reset(bool = false);
  bool has_tau() const;
  bool has_variance() const;
  result_type value() const;
  result_type mean() const;
  result_type variance() const;
  result_type error() const;
  convergence_type converged_errors() const;
  time_type tau() const;
  covariance_type covariance(SimpleObservableEvaluator &) const;
  count_type bin_number() const;
  const value_type & bin_value(count_type) const;
  count_type bin_number2() const;
  const value_type & bin_value2(count_type) const;
  count_type bin_size() const;
  count_type count() const;
  Observable * clone() const;
  uint32_t get_thermalization() const;
  bool can_set_thermalization() const;
  ALPS_DUMMY_VOID compact();
  SimpleObservableEvaluator< T > operator-() const;
  template<typename X> 
    const SimpleObservableEvaluator< T > & operator+=(const X &);
  template<typename X> 
    const SimpleObservableEvaluator< T > & operator-=(const X &);
  template<typename X> 
    const SimpleObservableEvaluator< T > & operator*=(const X &);
  template<typename X> 
    const SimpleObservableEvaluator< T > & operator/=(const X &);
  const SimpleObservableEvaluator< T > & 
  operator+=(const SimpleObservableEvaluator< T > &);
  const SimpleObservableEvaluator< T > & 
  operator-=(const SimpleObservableEvaluator< T > &);
  template<typename X> 
    const SimpleObservableEvaluator< T > & 
    operator*=(const SimpleObservableEvaluator< X > &);
  template<typename X> 
    const SimpleObservableEvaluator< T > & 
    operator/=(const SimpleObservableEvaluator< X > &);
  ALPS_DUMMY_VOID output(std::ostream &) const;
  void output_scalar(std::ostream &) const;
  void output_vector(std::ostream &) const;
  template<typename S> 
    SimpleObservableEvaluator< typename element_type< T >::type > 
    slice(const S &, const std::string &) const;
  template<typename S> 
    SimpleObservableEvaluator< typename element_type< T >::type > 
    slice(const S &) const;
  void operator<<(const SimpleObservableData< T > &);
  template<typename OPV> 
    const SimpleObservableEvaluator< T > & transform(OPV, const std::string &);
  void extract_timeseries(ODump &) const;
  void save(ODump &) const;
  void load(IDump &);
  template<typename X> void add_to(const X &);
  template<typename X> void subtract_from(const X &);
  template<typename X> void divide(const X &);
  template<typename X> void multiply_to(const X &);
  std::string evaluation_method(Target) const;
  void merge(const Observable &);
  bool can_merge() const;
  bool can_merge(const Observable &) const;
  Observable * convert_mergeable() const;
  SimpleObservableEvaluator< value_type > make_evaluator() const;
};

Description

SimpleObservableEvaluator public construct/copy/destruct

  1. SimpleObservableEvaluator(const std::string & n = "");

    almost default constructor

  2. SimpleObservableEvaluator(const char * n);
  3. SimpleObservableEvaluator(const SimpleObservableEvaluator & eval);

    copy constructor

  4. SimpleObservableEvaluator(const Observable & obs, const std::string & n);

    constructor from an observable

  5. SimpleObservableEvaluator(const Observable & obs);
  6. SimpleObservableEvaluator(const std::string & n, std::istream &, 
                              const XMLTag &);
  7. SimpleObservableEvaluator& 
    operator=(const SimpleObservableEvaluator< T > & eval);

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

  8. SimpleObservableEvaluator& 
    operator=(const AbstractSimpleObservable< T > & obs);

SimpleObservableEvaluator public member functions

  1. uint32_t version_id() const;
    return a version ID uniquely identifying the class
  2. SimpleObservableEvaluator< T > & 
    operator<<(const AbstractSimpleObservable< T > & obs);

    add an observable to the ones already in the class

  3. void rename(const std::string &);
    rename the observable
  4. void rename(const std::string & n, bool a);
  5. ALPS_DUMMY_VOID reset(bool equilibrated = false);

    reset the observable

  6. bool has_tau() const;
    is autocorrelation information available ?
  7. bool has_variance() const;
    is variance available ?
  8. result_type value() const;
  9. result_type mean() const;
    the mean value
  10. result_type variance() const;
    the variance
  11. result_type error() const;
    the error
  12. convergence_type converged_errors() const;
  13. time_type tau() const;
    the autocorrelation time, throws an exception if not available
  14. covariance_type covariance(SimpleObservableEvaluator & obs2) const;
  15. count_type bin_number() const;
    the number of bins
  16. const value_type & bin_value(count_type) const;
    the value of a bin
  17. count_type bin_number2() const;
    the number of bins with squared values
  18. const value_type & bin_value2(count_type) const;
    the squared value of a bin
  19. count_type bin_size() const;
    the number of measurements per bin
  20. count_type count() const;
    the number of measurements
  21. Observable * clone() const;

    clones the observable

  22. uint32_t get_thermalization() const;
  23. bool can_set_thermalization() const;
  24. ALPS_DUMMY_VOID compact();
  25. SimpleObservableEvaluator< T > operator-() const;
    negate
  26. template<typename X> 
      const SimpleObservableEvaluator< T > & operator+=(const X &);
    add a constant
  27. template<typename X> 
      const SimpleObservableEvaluator< T > & operator-=(const X &);
    subtract a constant
  28. template<typename X> 
      const SimpleObservableEvaluator< T > & operator*=(const X &);
    multiply with a constant
  29. template<typename X> 
      const SimpleObservableEvaluator< T > & operator/=(const X &);
    divide by a constant
  30. const SimpleObservableEvaluator< T > & 
    operator+=(const SimpleObservableEvaluator< T > &);
    add another observable
  31. const SimpleObservableEvaluator< T > & 
    operator-=(const SimpleObservableEvaluator< T > &);
    subtract another observable
  32. template<typename X> 
      const SimpleObservableEvaluator< T > & 
      operator*=(const SimpleObservableEvaluator< X > &);
    multiply by another observable
  33. template<typename X> 
      const SimpleObservableEvaluator< T > & 
      operator/=(const SimpleObservableEvaluator< X > &);
    divide by another observable
  34. ALPS_DUMMY_VOID output(std::ostream &) const;

    output the result

  35. void output_scalar(std::ostream &) const;
  36. void output_vector(std::ostream &) const;
  37. template<typename S> 
      SimpleObservableEvaluator< typename element_type< T >::type > 
      slice(const S &, const std::string &) const;
  38. template<typename S> 
      SimpleObservableEvaluator< typename element_type< T >::type > 
      slice(const S &) const;
  39. void operator<<(const SimpleObservableData< T > & obs);
  40. template<typename OPV> 
      const SimpleObservableEvaluator< T > & 
      transform(OPV opv, const std::string &);
  41. void extract_timeseries(ODump & dump) const;
  42. void save(ODump & dump) const;
  43. void load(IDump & dump);
  44. template<typename X> void add_to(const X & x);
  45. template<typename X> void subtract_from(const X & x);
  46. template<typename X> void divide(const X & x);
  47. template<typename X> void multiply_to(const X & x);
  48. std::string evaluation_method(Target t) const;
  49. void merge(const Observable &);
  50. bool can_merge() const;
    can this observable be merged with one of the same type
  51. bool can_merge(const Observable &) const;
    can this observable be merged with one of the given type
  52. Observable * convert_mergeable() const;
    create a copy of the observable that can be merged
  53. SimpleObservableEvaluator< value_type > make_evaluator() const;
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext