ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Class template binned_data

alps::alea::binned_data

Synopsis

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

template<typename T> 
class binned_data {
public:
  // types
  typedef T                                                                   value_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 change_value_type_replace_valarray< value_type, std::string >::type label_type;      
  typedef covariance_type< T >::type                                          covariance_type; 

  // construct/copy/destruct
  binned_data();
  template<typename X> binned_data(std::vector< X > const &);
  binned_data(AbstractSimpleObservable< value_type > const &);
  template<typename X, typename S> binned_data(binned_data< X > const &, S);
  template<typename X> binned_data(std::vector< X > const &, uint64_t const );
  template<typename X> binned_data& operator=(binned_data< X > const &);

  // public member functions
  uint64_t count() const;
  uint64_t bin_size() const;
  std::size_t bin_number() const;
  const std::vector< value_type > & bins() const;
  const result_type mean() const;
  const result_type error() const;
  const boost::optional< result_type > & variance() const;
  const boost::optional< time_type > & tau() const;
  covariance_type covariance(const binned_data< T >) const;
  void set_bin_size(uint64_t) ;
  void set_bin_number(uint64_t) ;
  template<typename S> 
    binned_data< typename element_type< T >::type > slice(S) const;
  template<typename X> bool operator==(binned_data< X > const &) ;
  binned_data< T > & operator+=(binned_data< T > const &) ;
  binned_data< T > & operator-=(binned_data< T > const &) ;
  template<typename X> 
    binned_data< T > & operator*=(binned_data< X > const &) ;
  template<typename X> 
    binned_data< T > & operator/=(binned_data< X > const &) ;
  template<typename X> binned_data< T > & operator+=(X const &) ;
  template<typename X> binned_data< T > & operator-=(X const &) ;
  template<typename X> binned_data< T > & operator*=(X const &) ;
  template<typename X> binned_data< T > & operator/=(X const &) ;
  template<typename X, typename OP> 
    void transform(const binned_data< X > &, OP) ;

  // private member functions
  void collect_bins(uint64_t) ;
  void analyze() const;
  void fill_jack() const;
  void jackknife() const;
  template<typename OP> void transform_linear(OP) ;
  template<typename OP> void transform(OP) ;
  template<typename X, typename OP> 
    void transform(const binned_data< X > &, OP, double = 1.) ;
};

Description

binned_data public construct/copy/destruct

  1. binned_data();
  2. template<typename X> binned_data(std::vector< X > const & bins);
  3. binned_data(AbstractSimpleObservable< value_type > const & obs);
  4. template<typename X, typename S> 
      binned_data(binned_data< X > const & my_binned_data, S s);
  5. template<typename X> 
      binned_data(std::vector< X > const & timeseries_measurements, 
                  uint64_t const  desired_bin_number);
  6. template<typename X> 
      binned_data& operator=(binned_data< X > const & my_binned_data);

binned_data public member functions

  1. uint64_t count() const;
  2. uint64_t bin_size() const;
  3. std::size_t bin_number() const;
  4. const std::vector< value_type > & bins() const;
  5. const result_type mean() const;
  6. const result_type error() const;
  7. const boost::optional< result_type > & variance() const;
  8. const boost::optional< time_type > & tau() const;
  9. covariance_type covariance(const binned_data< T >) const;
  10. void set_bin_size(uint64_t binsize) ;
  11. void set_bin_number(uint64_t bin_number) ;
  12. template<typename S> 
      binned_data< typename element_type< T >::type > slice(S s) const;
  13. template<typename X> bool operator==(binned_data< X > const & my_binned_data) ;
  14. binned_data< T > & operator+=(binned_data< T > const & rhs) ;
  15. binned_data< T > & operator-=(binned_data< T > const & rhs) ;
  16. template<typename X> 
      binned_data< T > & operator*=(binned_data< X > const & rhs) ;
  17. template<typename X> 
      binned_data< T > & operator/=(binned_data< X > const & rhs) ;
  18. template<typename X> binned_data< T > & operator+=(X const & rhs) ;
  19. template<typename X> binned_data< T > & operator-=(X const & rhs) ;
  20. template<typename X> binned_data< T > & operator*=(X const & rhs) ;
  21. template<typename X> binned_data< T > & operator/=(X const & rhs) ;
  22. template<typename X, typename OP> 
      void transform(const binned_data< X > & x, OP op) ;

binned_data private member functions

  1. void collect_bins(uint64_t) ;
  2. void analyze() const;
  3. void fill_jack() const;
  4. void jackknife() const;
  5. template<typename OP> void transform_linear(OP op) ;
  6. template<typename OP> void transform(OP op) ;
  7. template<typename X, typename OP> 
      void transform(const binned_data< X > & x, OP op, double factor = 1.) ;
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext