ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Class template mcdata

alps::alea::mcdata

Synopsis

// In header: <alps/alea/mcdata.hpp>

template<typename T> 
class mcdata {
public:
  // types
  typedef T                                    value_type;      
  typedef alps::element_type< T >::type        element_type;    
  typedef change_value_type< T, double >::type time_type;       
  typedef std::size_t                          size_type;       
  typedef double                               count_type;      
  typedef average_type< T >::type              result_type;     
  typedef change_value_type< T, int >::type    convergence_type;
  typedef covariance_type< T >::type           covariance_type; 

  // member classes/structs/unions

  class const_iterator {
  public:
    // construct/copy/destruct
    const_iterator();
    const_iterator(mcdata< T > const &, std::size_t);
    const_iterator(const_iterator const &);
    const_iterator& operator=(const_iterator const &);

    // public member functions
    mcdata< typename T::value_type > operator*() const;
    void operator++();
    bool operator==(const_iterator const &) const;
    const_iterator & operator+=(std::ptrdiff_t);
    bool operator<(const_iterator const &) const;
    std::ptrdiff_t operator-(const_iterator const &);
  };

  // construct/copy/destruct
  mcdata();
  mcdata(result_type, result_type = result_type());
  mcdata(boost::python::object const &);
  mcdata(boost::python::object const &, boost::python::object const &);
  template<typename X, typename S> mcdata(mcdata< X > const &, S);
  template<typename X, typename S> mcdata(mcdata< X > const &, S, S);
  template<typename X> mcdata(AbstractSimpleObservable< X > const &);
  mcdata(int64_t, value_type const &, value_type const &, 
         boost::optional< result_type > const &, 
         boost::optional< time_type > const &, uint64_t, 
         std::vector< value_type > const &);
  mcdata& operator=(mcdata< T >);

  // public member functions
  const_iterator begin() const;
  const_iterator end() const;
  bool can_rebin() const;
  bool jackknife_valid() const;
  void swap(mcdata< T > &);
  uint64_t count() const;
  uint64_t bin_size() const;
  uint64_t max_bin_number() const;
  std::size_t bin_number() const;
  std::vector< value_type > const & bins() const;
  result_type const & mean() const;
  result_type const & error() const;
  bool has_variance() const;
  result_type const & variance() const;
  bool has_tau() const;
  time_type const & tau() const;
  covariance_type covariance(mcdata< T > const &) const;
  void set_bin_size(uint64_t);
  void set_bin_number(uint64_t);
  void output(std::ostream &, boost::mpl::true_) const;
  void output(std::ostream &, boost::mpl::false_) const;
  void serialize(hdf5::iarchive &);
  void serialize(hdf5::oarchive &) const;
  void save(std::string const &, std::string const &) const;
  void load(std::string const &, std::string const &);
  mcdata< T > & operator<<(mcdata< T > const &);
  template<typename S> element_type slice(S) const;
  template<typename X> bool operator==(mcdata< X > const &) const;
  template<typename X> 
    bool operator==(mcdata< std::vector< X > > const &) const;
  template<typename X> bool operator!=(mcdata< X > const &) const;
  mcdata< T > & operator+=(mcdata< T > const &);
  mcdata< T > & operator-=(mcdata< T > const &);
  template<typename X> mcdata< T > & operator*=(mcdata< X > const &);
  template<typename X> mcdata< T > & operator/=(mcdata< X > const &);
  template<typename X> mcdata< T > & operator+=(X const &);
  template<typename X> mcdata< T > & operator-=(X const &);
  template<typename X> mcdata< T > & operator*=(X const &);
  template<typename X> mcdata< T > & operator/=(X const &);
  mcdata< T > & operator+();
  mcdata< T > & operator-();
  template<typename X> void subtract_from(X const &);
  template<typename X> void divide(X const &);
  template<typename OP> 
    void transform_linear(OP, value_type const &, 
                          boost::optional< result_type > = boost::none_t());
  template<typename OP> 
    void transform(OP, value_type const &, 
                   boost::optional< result_type > = boost::none_t());
  template<typename X, typename OP> 
    void transform(mcdata< X > const &, OP, value_type const &, 
                   boost::optional< result_type > = boost::none_t());

  // private member functions
  T const & replace_valarray_by_vector(T const &);
  template<typename X> 
    std::vector< X > replace_valarray_by_vector(std::valarray< X > const &);
  void collect_bins(uint64_t);
  void fill_jack() const;
  void analyze() const;
  template<typename Archive> void serialize(Archive &, const unsigned int);
};

Description

mcdata public construct/copy/destruct

  1. mcdata();
  2. mcdata(result_type mean, result_type error = result_type());
  3. mcdata(boost::python::object const & mean);
  4. mcdata(boost::python::object const & mean, 
           boost::python::object const & error);
  5. template<typename X, typename S> mcdata(mcdata< X > const & rhs, S s);
  6. template<typename X, typename S> mcdata(mcdata< X > const & rhs, S from, S to);
  7. template<typename X> mcdata(AbstractSimpleObservable< X > const & obs);
  8. 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, 
           std::vector< value_type > const & values);
  9. mcdata& operator=(mcdata< T > rhs);

mcdata public member functions

  1. const_iterator begin() const;
  2. const_iterator end() const;
  3. bool can_rebin() const;
  4. bool jackknife_valid() const;
  5. void swap(mcdata< T > & rhs);
  6. uint64_t count() const;
  7. uint64_t bin_size() const;
  8. uint64_t max_bin_number() const;
  9. std::size_t bin_number() const;
  10. std::vector< value_type > const & bins() const;
  11. result_type const & mean() const;
  12. result_type const & error() const;
  13. bool has_variance() const;
  14. result_type const & variance() const;
  15. bool has_tau() const;
  16. time_type const & tau() const;
  17. covariance_type covariance(mcdata< T > const & obs) const;
  18. void set_bin_size(uint64_t binsize);
  19. void set_bin_number(uint64_t bin_number);
  20. void output(std::ostream & out, boost::mpl::true_) const;
  21. void output(std::ostream & out, boost::mpl::false_) const;
  22. void serialize(hdf5::iarchive & ar);
  23. void serialize(hdf5::oarchive & ar) const;
  24. void save(std::string const & filename, std::string const & path) const;
  25. void load(std::string const & filename, std::string const & path);
  26. mcdata< T > & operator<<(mcdata< T > const & rhs);
  27. template<typename S> element_type slice(S s) const;
  28. template<typename X> bool operator==(mcdata< X > const & rhs) const;
  29. template<typename X> 
      bool operator==(mcdata< std::vector< X > > const & rhs) const;
  30. template<typename X> bool operator!=(mcdata< X > const & rhs) const;
  31. mcdata< T > & operator+=(mcdata< T > const & rhs);
  32. mcdata< T > & operator-=(mcdata< T > const & rhs);
  33. template<typename X> mcdata< T > & operator*=(mcdata< X > const & rhs);
  34. template<typename X> mcdata< T > & operator/=(mcdata< X > const & rhs);
  35. template<typename X> mcdata< T > & operator+=(X const & rhs);
  36. template<typename X> mcdata< T > & operator-=(X const & rhs);
  37. template<typename X> mcdata< T > & operator*=(X const & rhs);
  38. template<typename X> mcdata< T > & operator/=(X const & rhs);
  39. mcdata< T > & operator+();
  40. mcdata< T > & operator-();
  41. template<typename X> void subtract_from(X const & x);
  42. template<typename X> void divide(X const & x);
  43. template<typename OP> 
      void transform_linear(OP op, value_type const & error, 
                            boost::optional< result_type > variance_opt = boost::none_t());
  44. template<typename OP> 
      void transform(OP op, value_type const & error, 
                     boost::optional< result_type > variance_opt = boost::none_t());
  45. template<typename X, typename OP> 
      void transform(mcdata< X > const & rhs, OP op, value_type const & error, 
                     boost::optional< result_type > variance_opt = boost::none_t());

mcdata private member functions

  1. T const & replace_valarray_by_vector(T const & value);
  2. template<typename X> 
      std::vector< X > 
      replace_valarray_by_vector(std::valarray< X > const & value);
  3. void collect_bins(uint64_t howmany);
  4. void fill_jack() const;
  5. void analyze() const;
  6. template<typename Archive> 
      void serialize(Archive & ar, const unsigned int version);
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext