ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Reference

Header <alps/alea/abstractbinning.h>
Header <alps/alea/abstractsimpleobservable.h>
Header <alps/alea/convergence.hpp>
Header <alps/alea/detailedbinning.h>
Header <alps/alea/histogram.h>
Header <alps/alea/histogramdata.h>
Header <alps/alea/histogrameval.h>
Header <alps/alea/mcanalyze.hpp>
Header <alps/alea/mcdata.hpp>
Header <alps/alea/nan.h>
Header <alps/alea/nobinning.h>
Header <alps/alea/observable.h>
Header <alps/alea/observable_fwd.hpp>
Header <alps/alea/observablefactory.h>
Header <alps/alea/observableset.h>
Header <alps/alea/observableset_p.h>
Header <alps/alea/output_helper.h>
Header <alps/alea/recordableobservable.h>
Header <alps/alea/signedobservable.h>
Header <alps/alea/simplebinning.h>
Header <alps/alea/simpleobsdata.h>
Header <alps/alea/simpleobservable.h>
Header <alps/alea/simpleobseval.h>
Header <alps/alea/type_tag.hpp>
Header <alps/alea/value_with_error.hpp>
namespace alps {
  template<typename T> class AbstractBinning;
}
namespace alps {
  template<typename T> class AbstractSimpleObservable;

  class ALPS_TEMPL_DECL SimpleObservableEvaluator;
  template<typename T> bool error_underflow(T mean, T error);
  template<typename T> 
    bool error_underflow(std::complex< T > mean, std::complex< T > error);
}
namespace alps {

  enum error_convergence { CONVERGED, MAYBE_CONVERGED, NOT_CONVERGED };
  std::string convergence_to_text(int c);
}
namespace alps {
  template<typename T = double> class BasicDetailedBinning;
  template<typename T> class DetailedBinning;
  template<typename T> class FixedBinning;

  typedef SimpleObservable< int32_t, DetailedBinning< int32_t > > IntObservable;
  typedef SimpleObservable< double, DetailedBinning< double > > RealObservable;
  typedef SimpleObservable< float, DetailedBinning< float > > FloatObservable;
  typedef SimpleObservable< std::complex< double >, DetailedBinning< std::complex< double > > > ComplexObservable;
  typedef SimpleObservable< double, FixedBinning< double > > RealTimeSeriesObservable;
  typedef SimpleObservable< int32_t, FixedBinning< int32_t > > IntTimeSeriesObservable;
  typedef SimpleObservable< std::valarray< int32_t >, DetailedBinning< std::valarray< int32_t > > > IntVectorObservable;
  typedef SimpleObservable< std::valarray< double >, DetailedBinning< std::valarray< double > > > RealVectorObservable;
  typedef SimpleObservable< std::valarray< float >, DetailedBinning< std::valarray< float > > > FloatVectorObservable;
  typedef SimpleObservable< std::valarray< int32_t >, FixedBinning< std::valarray< int32_t > > > IntVectorTimeSeriesObservable;
  typedef SimpleObservable< std::valarray< double >, FixedBinning< std::valarray< double > > > RealVectorTimeSeriesObservable;
}
namespace alps {
  template<typename T> class HistogramObservable;

  typedef HistogramObservable< int32_t > IntHistogramObservable;
  typedef HistogramObservable< double > RealHistogramObservable;
}
namespace alps {
  template<typename T> class HistogramObservableData;
}
namespace alps {
  template<typename T> class HistogramObservableEvaluator;

  typedef HistogramObservableEvaluator< int32_t > IntHistogramObsevaluator;
  typedef HistogramObservableEvaluator< double > RealHistogramObsevaluator;
}

ALPS_ALEA_IMPL_DISTANCE_LIMIT_FUNCTION(name)
ALPS_ALEA_IMPL_FROM_TO_MIN_MAX_FUNCTION(name)
ALPS_MCANALYZE_IMPLEMENT_OSTREAM(timeseries_type)
namespace alps {
  namespace alea {
    class None_class;

    template<typename T> struct const_iterator_type;

    template<typename ValueType> 
      struct const_iterator_type<alps::alea::mcdata< ValueType >>;

    template<typename T> struct iterator_type;

    template<typename ValueType> 
      struct iterator_type<alps::alea::mcdata< ValueType >>;

    template<typename ValueType> class mctimeseries;
    template<typename ValueType> class mctimeseries_view;
    class NotEnoughMeasurementsError;

    struct uncorrelated_selector;
    struct binning_selector;

    class alps::alea::None_class None;
    struct alps::alea::uncorrelated_selector uncorrelated;
    struct alps::alea::binning_selector binning;
    template<typename TimeseriesType> 
      const_iterator_type< TimeseriesType >::type 
      range_begin(const TimeseriesType & timeseries);
    template<typename ValueType> 
      std::vector< ValueType >::const_iterator 
      range_begin(const alps::alea::mcdata< ValueType > & timeseries);
    template<typename TimeseriesType> 
      const_iterator_type< TimeseriesType >::type 
      range_end(const TimeseriesType & timeseries);
    template<typename ValueType> 
      std::vector< ValueType >::const_iterator 
      range_end(const alps::alea::mcdata< ValueType > & timeseries);
    template<typename TimeseriesType> 
      mctimeseries_view< typename TimeseriesType::value_type > 
      cut_head_distance(const TimeseriesType & timeseries, int cutoff);
    template<typename TimeseriesType> 
      mctimeseries_view< typename TimeseriesType::value_type > 
      cut_tail_distance(const TimeseriesType & timeseries, int cutoff);
    template<typename TimeseriesType> 
      mctimeseries_view< typename TimeseriesType::value_type > 
      cut_head_limit(const TimeseriesType & timeseries, double limit);
    template<typename TimeseriesType> 
      mctimeseries_view< typename TimeseriesType::value_type > 
      cut_tail_limit(const TimeseriesType & timeseries, double limit);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      mean(const TimeseriesType & timeseries);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      variance(const TimeseriesType & timeseries);
    template<typename TimeseriesType> 
      mctimeseries< typename average_type< typename TimeseriesType::value_type >::type > 
      autocorrelation_distance(const TimeseriesType & timeseries, int up_to);
    template<typename TimeseriesType> 
      mctimeseries< typename average_type< typename TimeseriesType::value_type >::type > 
      autocorrelation_limit(const TimeseriesType & timeseries, double limit);
    template<typename TimeseriesType> 
      std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type > 
      exponential_autocorrelation_time_distance(const TimeseriesType & autocorrelation, 
                                                int from, int to);
    template<typename TimeseriesType> 
      std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type > 
      exponential_autocorrelation_time_limit(const TimeseriesType & autocorrelation, 
                                             double max, double min);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      integrated_autocorrelation_time(const TimeseriesType & autocorrelation, 
                                      const std::pair< typename average_type< typename TimeseriesType::value_type >::type, typename average_type< typename TimeseriesType::value_type >::type > & tau);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      error(const TimeseriesType & timeseries, 
            const uncorrelated_selector & selector = alps::alea::uncorrelated);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      error(const TimeseriesType & timeseries, 
            const binning_selector & selector);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      uncorrelated_error(const TimeseriesType & timeseries);
    template<typename TimeseriesType> 
      average_type< typename TimeseriesType::value_type >::type 
      binning_error(const TimeseriesType & timeseries);
    template<typename TimeseriesType> 
      mctimeseries< typename average_type< typename TimeseriesType::value_type >::type > 
      running_mean(const TimeseriesType & timeseries);
    template<typename TimeseriesType> 
      mctimeseries< typename average_type< typename TimeseriesType::value_type >::type > 
      reverse_running_mean(const TimeseriesType & timeseries);
  }
}
namespace alps {
  namespace alea {
    template<typename T> class mcdata;
    template<typename T> 
      std::ostream & operator<<(std::ostream & out, mcdata< T > const & obs);
     ALPS_ALEA_MCDATA_IMPLEMENT_OPERATION(operator+, +);
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(atan, 
                                         abs(1./(1.+rhs.mean()*rhs.mean())*rhs.error()));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(abs, rhs. error);
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sq, abs(2.*rhs.mean()*rhs.error()));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cb, 
                                         abs(3.*sq(rhs.mean())*rhs.error()));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(sqrt, 
                                         abs(rhs.error()/(2.*sqrt(rhs.mean()))));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(cbrt, 
                                         abs(rhs.error()/(3.*sq(pow(rhs.mean(), 1./3)))));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(exp, exp(rhs.mean())*rhs.error());
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(log, abs(rhs.error()/rhs.mean()));
  }
}

Header <alps/alea/nan.h>

namespace alps {
  ALPS_DECL double nan();
  ALPS_DECL double inf();
  ALPS_DECL double ninf();
}
namespace alps {
  template<typename T = double> class NoBinning;

  typedef SimpleObservable< int32_t, NoBinning< int32_t > > SimpleIntObservable;
  typedef SimpleObservable< double, NoBinning< double > > SimpleRealObservable;
  typedef SimpleObservable< float, NoBinning< float > > SimpleFloatObservable;
  typedef SimpleObservable< std::complex< double >, NoBinning< std::complex< double > > > SimpleComplexObservable;
  typedef SimpleObservable< std::valarray< int32_t >, NoBinning< std::valarray< int32_t > > > SimpleIntVectorObservable;
  typedef SimpleObservable< std::valarray< double >, NoBinning< std::valarray< double > > > SimpleRealVectorObservable;
  typedef SimpleObservable< std::valarray< float >, NoBinning< std::valarray< float > > > SimpleFloatVectorObservable;
  typedef SimpleObservable< std::valarray< std::complex< double > >, NoBinning< std::valarray< std::complex< double > > > > SimpleComplexVectorObservable;
}
namespace alps {
  class NoMeasurementsError;
  class Observable;

  enum Target { Mean, Error, Variance, Tau };

  class ALPS_DECL ObservableSet;

  // write an observable to a std::ostream 
  std::ostream & operator<<(std::ostream & out, const alps::Observable & m);
}
namespace alps {
  class ObservableFactory;
}
namespace alps {
  class ObservableSet;

  // output all observables in an ObservableSet
  std::ostream & 
  operator<<(std::ostream & out, const alps::ObservableSet & obs);
}
namespace alps {
  class ObsValueXMLHandler;
  class RealObsevaluatorValueXMLHandler;
  class RealObsevaluatorXMLHandler;
  class RealVectorObsevaluatorXMLHandler;
  class RealHistogramEntryXMLHandler;
  class RealHistogramObservableXMLHandler;
  class ObservableSetXMLHandler;
}
namespace alps {
  template<typename FLAG> struct output_helper;

  template<> struct output_helper<boost::mpl::true_>;
  template<> struct output_helper<boost::mpl::false_>;
}
namespace alps {
  template<typename T = double, typename SIGN = double> 
    class RecordableObservable;
}
namespace alps {
  template<typename OBS, typename SIGN = double> 
    class AbstractSignedObservable;
  class A;
  template<typename OBS, typename SIGN = double> class SignedObservable;
  template<typename OBS> 
    boost::shared_ptr< Observable > 
    make_observable(const OBS & obs, bool issigned = false);
  template<typename OBS, typename SIGN> 
    boost::shared_ptr< Observable > 
    make_observable(const OBS & obs, const std::string & s, SIGN, 
                    bool issigned = true);
}
namespace alps {
  template<typename T = double> class SimpleBinning;
}
namespace alps {
  template<typename T> class SimpleObservableData;
  double text_to_double(const std::string & val);
}
template<typename T> 
  std::ostream & operator<<(std::ostream & o, const std::valarray< T > &);
namespace alps {
  template<typename T, typename BINNING> class SimpleObservable;
  template<typename T, typename BINNING> 
    hdf5::archive & 
    operator<<(hdf5::archive & ar, SimpleObservable< T, BINNING > const & obs);
  template<typename T, typename BINNING> 
    hdf5::archive & 
    operator>>(hdf5::archive & ar, SimpleObservable< T, BINNING > & obs);
}

OBSERVABLE_FUNCTION(F)
namespace alps {
  struct ObservableNamingHelper;

  template<typename T> class SimpleObservableEvaluator;

  typedef SimpleObservableEvaluator< double > RealObsevaluator;
  typedef SimpleObservableEvaluator< int32_t > IntObsevaluator;
  typedef SimpleObservableEvaluator< std::complex< double > > ComplexObsevaluator;
  typedef SimpleObservableEvaluator< std::valarray< int32_t > > IntVectorObsevaluator;
  typedef SimpleObservableEvaluator< std::valarray< double > > RealVectorObsevaluator;

  // sum of two observables 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator+(alps::SimpleObservableEvaluator< T > const & x, 
              const alps::SimpleObservableEvaluator< U > & y);

  // sum of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator+(alps::SimpleObservableEvaluator< T > const & x, const Y & y);

  // sum of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator+(const Y & y, alps::SimpleObservableEvaluator< T > const & x);

  // difference of two observables (IBM AIX workaround) 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator-(const alps::SimpleObservableEvaluator< T > & x, 
              const alps::SimpleObservableEvaluator< U > & y);

  // difference of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator-(alps::SimpleObservableEvaluator< T > const & x, const Y & y);

  // difference of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator-(const Y & y, alps::SimpleObservableEvaluator< T > const & x);

  // product of two observables (IBM AIX workaround) 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator*(const alps::SimpleObservableEvaluator< T > & x, 
              const alps::SimpleObservableEvaluator< U > & y);

  // product of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator*(alps::SimpleObservableEvaluator< T > const & x, const Y & y);

  // product of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator*(const Y & y, alps::SimpleObservableEvaluator< T > const & x);

  // product of vector and scalar observable 
  template<typename T> 
    alps::SimpleObservableEvaluator< std::valarray< T > > 
    operator*(alps::SimpleObservableEvaluator< std::valarray< T > > const & x, 
              const alps::SimpleObservableEvaluator< T > & y);

  // product of vector and scalar observable 
  template<typename T> 
    alps::SimpleObservableEvaluator< std::valarray< T > > 
    operator*(const alps::SimpleObservableEvaluator< T > & y, 
              alps::SimpleObservableEvaluator< std::valarray< T > > const & x);

  // ratio of two observables (IBM AIX workaround) 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator/(const alps::SimpleObservableEvaluator< T > & x, 
              const alps::SimpleObservableEvaluator< U > & y);

  // ratio of observable and number 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator/(alps::SimpleObservableEvaluator< T > const & x, const Y & y);

  // ratio of number and observable 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator/(const Y & x, alps::SimpleObservableEvaluator< T > const & y);
  template<typename T> 
    alps::SimpleObservableEvaluator< T > 
    pow(const alps::SimpleObservableEvaluator< T > & x, double p);
  template<typename T> 
    alps::SimpleObservableEvaluator< T > 
    pow(const alps::SimpleObservableEvaluator< T > & x, int p);
}

IMPLEMENT_OPERATION(OPERATOR_NAME, OPERATOR_ASSIGN)
IMPLEMENT_OPERATION2(OPERATOR_NAME, OPERATOR_ASSIGN)
IMPLEMENT_VECTOR_OF_VALUE_WITH_ERROR_FUNCTION(NAME1, NAME2)
namespace alps {
  namespace alea {
    template<typename T> class value_with_error;
    template<typename T> 
      std::ostream & 
      operator<<(std::ostream & out, value_with_error< T > const & value);
    template<typename T> 
      std::ostream & 
      operator<<(std::ostream & out, 
                 value_with_error< std::vector< T > > const & vec);
    template<typename T> 
      value_with_error< T > & operator+(value_with_error< T > & rhs);
    template<typename T> 
      value_with_error< T > operator-(value_with_error< T > rhs);
    template<typename T> value_with_error< T > abs(value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > 
      operator+(T const & lhs, value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > 
      operator-(T const & lhs, value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > 
      operator*(T const & lhs, value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > 
      operator/(T const & lhs, value_with_error< T > const & rhs);
    template<typename T> 
      value_with_error< T > 
      pow(value_with_error< T > rhs, 
          typename value_with_error< T >::element_type const & exponent);
    template<typename T> value_with_error< T > sq(value_with_error< T > rhs);
    template<typename T> value_with_error< T > cb(value_with_error< T > rhs);
    template<typename T> value_with_error< T > sqrt(value_with_error< T > rhs);
    template<typename T> value_with_error< T > cbrt(value_with_error< T > rhs);
    template<typename T> value_with_error< T > exp(value_with_error< T > rhs);
    template<typename T> value_with_error< T > log(value_with_error< T > rhs);
    template<typename T> value_with_error< T > sin(value_with_error< T > rhs);
    template<typename T> value_with_error< T > cos(value_with_error< T > rhs);
    template<typename T> value_with_error< T > tan(value_with_error< T > rhs);
    template<typename T> value_with_error< T > sinh(value_with_error< T > rhs);
    template<typename T> value_with_error< T > cosh(value_with_error< T > rhs);
    template<typename T> value_with_error< T > tanh(value_with_error< T > rhs);
    template<typename T> value_with_error< T > asin(value_with_error< T > rhs);
    template<typename T> value_with_error< T > acos(value_with_error< T > rhs);
    template<typename T> value_with_error< T > atan(value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > asinh(value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > acosh(value_with_error< T > rhs);
    template<typename T> 
      value_with_error< T > atanh(value_with_error< T > rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator+(std::vector< value_with_error< T > > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator+(std::vector< value_with_error< T > > const & lhs, 
                T const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator+(T const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator+(std::vector< value_with_error< T > > const & lhs, 
                std::vector< T > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator+(std::vector< T > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator-(std::vector< value_with_error< T > > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator-(std::vector< value_with_error< T > > const & lhs, 
                T const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator-(T const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator-(std::vector< value_with_error< T > > const & lhs, 
                std::vector< T > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator-(std::vector< T > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator*(std::vector< value_with_error< T > > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator*(std::vector< value_with_error< T > > const & lhs, 
                T const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator*(T const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator*(std::vector< value_with_error< T > > const & lhs, 
                std::vector< T > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator*(std::vector< T > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator/(std::vector< value_with_error< T > > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator/(std::vector< value_with_error< T > > const & lhs, 
                T const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator/(T const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator/(std::vector< value_with_error< T > > const & lhs, 
                std::vector< T > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      operator/(std::vector< T > const & lhs, 
                std::vector< value_with_error< T > > const & rhs);
    template<typename T> 
      std::vector< T > operator-(std::vector< T > const & rhs);
    template<typename T> 
      std::vector< value_with_error< T > > 
      vec_pow(std::vector< value_with_error< T > > const & rhs, 
              T const & exponent);
    template<typename T> 
      std::vector< value_with_error< T > > 
      obtain_vector_of_value_with_error_from_vector_with_error(value_with_error< std::vector< T > > vec_with_error);
    template<typename T> 
      value_with_error< std::vector< T > > 
      obtain_vector_with_error_from_vector_of_value_with_error(std::vector< value_with_error< T > > vec_of_value_with_error);
  }
}
Copyright 1994, 2002-2004, 2012 Matthias Troyer, Synge Todo, Maximilian Poprawe

PrevUpHomeNext