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/mcdata.hpp>
Header <alps/alea/nan.h>
Header <alps/alea/nobinning.h>
Header <alps/alea/observable.h>
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>
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;
}
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;
}
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(asinh, 
                                         abs(1./sqrt(rhs.mean()*rhs.mean()+1.)*rhs.error()));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(acosh, 
                                         abs(1./sqrt(rhs.mean()*rhs.mean()-1.)*rhs.error()));
     ALPS_ALEA_MCDATA_IMPLEMENT_FUNCTION(atanh, 
                                         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;
}
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 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;
  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;
}

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;

  // 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);
}
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext