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>
Header <alps/alea/value_with_error.h>
namespace alps {
  template<typename T> class AbstractBinning;
}
namespace alps {
  template<typename T> class AbstractSimpleObservable;
  template<typename T> bool error_underflow(T mean, 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_OPERATION(operator*, *, *);
    template<typename T> mcdata< T > operator+(T const & lhs, mcdata< T > rhs);
    template<typename T> mcdata< T > operator-(T const & lhs, mcdata< T > rhs);
    template<typename T> mcdata< T > operator*(T const & lhs, mcdata< T > rhs);
    template<typename T> mcdata< T > operator/(T const & lhs, mcdata< T > rhs);
    template<typename T> mcdata< T > pow(mcdata< T > rhs, double exponent);
    template<typename T> mcdata< T > sq(mcdata< T > rhs);
    template<typename T> mcdata< T > cb(mcdata< T > rhs);
    template<typename T> mcdata< T > sqrt(mcdata< T > rhs);
    template<typename T> mcdata< T > cbrt(mcdata< T > rhs);
    template<typename T> mcdata< T > exp(mcdata< T > rhs);
    template<typename T> mcdata< T > log(mcdata< T > rhs);
    template<typename T> mcdata< T > sin(mcdata< T > rhs);
    template<typename T> mcdata< T > cos(mcdata< T > rhs);
    template<typename T> mcdata< T > tan(mcdata< T > rhs);
    template<typename T> mcdata< T > sinh(mcdata< T > rhs);
    template<typename T> mcdata< T > cosh(mcdata< T > rhs);
    template<typename T> mcdata< T > tanh(mcdata< T > rhs);
    template<typename T> mcdata< T > asin(mcdata< T > rhs);
    template<typename T> mcdata< T > acos(mcdata< T > rhs);
    template<typename T> mcdata< T > atan(mcdata< T > rhs);
    template<typename T> mcdata< T > asinh(mcdata< T > rhs);
    template<typename T> mcdata< T > acosh(mcdata< T > rhs);
    template<typename T> mcdata< T > atanh(mcdata< T > rhs);
  }
}

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 > x, 
              const alps::SimpleObservableEvaluator< U > & y);

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

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

  // difference of two observables 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator-(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 > x, const Y & y);

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

  // product of two observables 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator*(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 > x, const Y & y);

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

  // product of vector and scalar observable 
  template<typename T> 
    alps::SimpleObservableEvaluator< std::valarray< T > > 
    operator*(alps::SimpleObservableEvaluator< std::valarray< T > > 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 > > x);

  // ratio of two observables 
  template<typename T, typename U> 
    alps::SimpleObservableEvaluator< T > 
    operator/(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 > x, const Y & y);

  // ratio of number and observable 
  template<typename T, typename Y> 
    alps::SimpleObservableEvaluator< T > 
    operator/(const Y & x, alps::SimpleObservableEvaluator< T > 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-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext