ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Reference

Header <alps/alea.h>
Header <alps/cctype.h>
Header <alps/expression.h>
Header <alps/factory.h>
Header <alps/fixed_capacity_deque.h>
Header <alps/fixed_capacity_fwd.h>
Header <alps/fixed_capacity_traits.h>
Header <alps/fixed_capacity_vector.h>
Header <alps/functional.h>
Header <alps/hdf5.hpp>
Header <alps/hdf5_fwd.hpp>
Header <alps/lambda.hpp>
Header <alps/lattice.h>
Header <alps/model.h>
Header <alps/multi_array.hpp>
Header <alps/ngs.hpp>
Header <alps/osiris.h>
Header <alps/plot.h>
Header <alps/random.h>
Header <alps/stringvalue.h>
Header <alps/xml.h>

Header <alps/alea.h>

includes all headers in the alps/alea directory

Header <alps/cctype.h>

A safe version of the standard cctype header.

Some cctype headers do not undefine harmful macros, so undefine them here.

includes all headers in the alps/expression directory

Header <alps/factory.h>

object factories

This header contains an implementation of an object factory

namespace alps {
  template<typename KEY, typename BASE> class factory;
}
namespace alps {
  template<typename T, std::size_t N, typename CheckingPolicy> 
    class fixed_capacity_deque;
  template<typename T, std::size_t N> 
    bool operator==(const fixed_capacity_deque< T, N > & x, 
                    const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator<(const fixed_capacity_deque< T, N > & x, 
                   const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator!=(const fixed_capacity_deque< T, N > & x, 
                    const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator>(const fixed_capacity_deque< T, N > & x, 
                   const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator<=(const fixed_capacity_deque< T, N > & x, 
                    const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator>=(const fixed_capacity_deque< T, N > & x, 
                    const fixed_capacity_deque< T, N > & y);
  template<typename T, std::size_t N> 
    void swap(fixed_capacity_deque< T, N > & x, 
              fixed_capacity_deque< T, N > & y);
  namespace fixed_capacity {
    template<typename T, std::size_t N, typename Ref, typename Ptr> 
      struct deque_iterator;
  }
}
namespace std {
}namespace alps {
  template<typename C> struct fixed_capacity_traits;

  template<typename T, std::size_t N, typename C> 
    struct fixed_capacity_traits<fixed_capacity_vector< T, N, C >>;
  template<typename T, std::size_t N, typename C> 
    struct fixed_capacity_traits<fixed_capacity_deque< T, N, C >>;
  template<typename T, typename C> 
    struct fixed_capacity_traits<std::stack< T, C >>;
  template<typename T, typename C> 
    struct fixed_capacity_traits<std::queue< T, C >>;
  template<typename T, typename C, typename Cmp> 
    struct fixed_capacity_traits<std::priority_queue< T, C, Cmp >>;
}
namespace alps {
  template<typename T, std::size_t N, typename CheckingPolicy> 
    class fixed_capacity_vector;
  template<typename T, std::size_t N> 
    bool operator==(const fixed_capacity_vector< T, N > & x, 
                    const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator<(const fixed_capacity_vector< T, N > & x, 
                   const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator!=(const fixed_capacity_vector< T, N > & x, 
                    const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator>(const fixed_capacity_vector< T, N > & x, 
                   const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator<=(const fixed_capacity_vector< T, N > & x, 
                    const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    bool operator>=(const fixed_capacity_vector< T, N > & x, 
                    const fixed_capacity_vector< T, N > & y);
  template<typename T, std::size_t N> 
    void swap(fixed_capacity_vector< T, N > & x, 
              fixed_capacity_vector< T, N > & y);
}

extensions to the standard functional header

This header contains mathematical function objects not present in the standard or boost libraries.

namespace alps {
  template<typename T> struct conj_mult;

  template<typename T> struct conj_mult<std::complex< T >>;
}

Header <alps/hdf5.hpp>


_HDF5USEDLL_
_HDF5USEHLDLL_
ALPS_HDF5_SZIP_BLOCK_SIZE
ALPS_HDF5_STRINGIFY(arg)
ALPS_HDF5_STRINGIFY_HELPER(arg)
ALPS_HDF5_THROW_ERROR(error, message)
ALPS_HDF5_THROW_RUNTIME_ERROR(message)
ALPS_HDF5_THROW_RANGE_ERROR(message)
ALPS_HDF5_DEFINE_VECTOR_TYPE(C)
ALPS_HDF5_FOREACH_SCALAR_NO_LONG_LONG(callback)
ALPS_HDF5_FOREACH_SCALAR(callback)
ALPS_HDF5_GET_STRING(U)
ALPS_HDF5_DEFINE_VECTOR_TYPE2(C)
namespace alps {
  template<typename T> 
    boost::disable_if< typename boost::mpl::and_< typename boost::is_same< typename boost::remove_cv< typename boost::remove_all_extents< T >::type >::type, char >::type, typename boost::is_array< T >::type >::type, hdf5::pvp< T & > >::type 
    make_pvp(std::string const & p, T & v);
  template<typename T> 
    boost::disable_if< typename boost::mpl::and_< typename boost::is_same< typename boost::remove_cv< typename boost::remove_all_extents< T >::type >::type, char >::type, typename boost::is_array< T >::type >::type, hdf5::pvp< T const & > >::type 
    make_pvp(std::string const & p, T const & v);
  template<typename T> 
    hdf5::pvp< std::pair< T *, std::vector< std::size_t > > > 
    make_pvp(std::string const & p, T * v, std::size_t s);
  template<typename T> 
    hdf5::pvp< std::pair< T *, std::vector< std::size_t > > > 
    make_pvp(std::string const & p, T * v, 
             std::vector< std::size_t > const & s);
  namespace hdf5 {
    template<typename T> struct serializable_type;
    template<typename T> struct native_type;
    template<typename T> struct is_native;
    template<typename T> struct is_cplx;

    template<> struct serializable_type<bool>;
    template<> struct native_type<bool>;
    template<> struct is_native<bool>;
    template<> struct is_native<bool const>;
    template<> struct serializable_type<std::string>;
    template<> struct native_type<std::string>;
    template<> struct is_native<std::string>;
    template<> struct is_native<std::string const>;
    template<> struct serializable_type<detail::internal_state_type::type>;
    template<> struct native_type<detail::internal_state_type::type>;
    template<> struct is_native<detail::internal_state_type::type>;
    template<> struct is_native<detail::internal_state_type::type const>;
    template<typename T> struct is_cplx<std::complex< T >>;
    template<typename T> struct serializable_type<std::complex< T >>;
    template<typename T> struct native_type<std::complex< T >>;
    template<typename T> struct is_native<std::complex< T >>;
    template<typename T> struct is_native<std::complex< T > const>;
    template<typename T> 
      struct serializable_type<std::pair< T *, std::vector< std::size_t > >>;
    template<typename T> 
      struct native_type<std::pair< T *, std::vector< std::size_t > >>;
    template<typename T> 
      struct is_cplx<std::pair< T *, std::vector< std::size_t > >>;

    class archive;
    class iarchive;
    class oarchive;
    template<typename T> class pvp;
    template<typename T> std::vector< hsize_t > call_get_extent(T const &);
    template<typename T> 
      void call_set_extent(T &, std::vector< std::size_t > const &);
    template<typename T> std::vector< hsize_t > call_get_offset(T const &);
    template<typename T> bool call_is_vectorizable(T const &);
    template<typename T, typename U> 
      U const * call_get_data(std::vector< U > &, T const &, 
                              std::vector< hsize_t > const &, 
                              boost::optional< std::vector< hsize_t > > const & t = boost::none_t());
    template<typename T, typename U> 
      void call_set_data(T &, std::vector< U > const &, 
                         std::vector< hsize_t > const &, 
                         std::vector< hsize_t > const &);
    template<typename T> std::vector< hsize_t > get_extent(T const &);
    template<typename T> 
      void set_extent(T &, std::vector< std::size_t > const &);
    template<typename T> std::vector< hsize_t > get_offset(T const &);
    template<typename T> bool is_vectorizable(T const &);
    template<typename T> 
      unspecified get_data(std::vector< typename serializable_type< T >::type > & m, 
                           T const & v, std::vector< hsize_t > const &, 
                           std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      void set_data(T & v, std::vector< U > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      boost::enable_if< typename boost::is_same< T, bool >::type, typename serializable_type< T >::type const * >::type 
      get_data(std::vector< serializable_type< bool >::type > & m, 
               T const & v, std::vector< hsize_t > const &, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T> 
      boost::enable_if< typename boost::is_same< T, std::string >::type, typename serializable_type< T >::type const * >::type 
      get_data(std::vector< serializable_type< std::string >::type > & m, 
               T const & v, std::vector< hsize_t > const &, 
               std::vector< hsize_t > const & t = std::vector< hsize_t >());
    template<typename T> 
      boost::disable_if< typename boost::mpl::or_< typename boost::is_same< T, std::complex< double > >::type, typename boost::is_same< T, char * >::type >::type >::type 
      set_data(std::string & v, std::vector< T > const & u, 
               std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & c);
    template<typename T> 
      unspecified get_data(unspecified m, T const & v, 
                           std::vector< hsize_t > const &, 
                           std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T> 
      void set_data(unspecified v, std::vector< T > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const &);
    template<typename T> bool is_vectorizable(std::complex< T > const &);
    template<typename T> 
      std::vector< hsize_t > get_offset(std::complex< T > const &);
    template<typename T> 
      void set_extent(std::complex< T > &, 
                      std::vector< std::size_t > const & s);
    template<typename T> 
      std::vector< hsize_t > get_extent(std::complex< T > const & v);
    template<typename T> 
      serializable_type< std::complex< T > >::type const * 
      get_data(std::vector< typename serializable_type< std::complex< T > >::type > & m, 
               std::complex< T > const & v, std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      boost::disable_if< typename boost::mpl::or_< typename boost::is_same< U, T >::type, typename boost::is_same< U, std::complex< T > >::type >::type >::type 
      set_data(std::complex< T > &, std::vector< U > const &, 
               std::vector< hsize_t > const &, 
               std::vector< hsize_t > const &);
    template<typename T> 
      void set_data(std::complex< T > & v, std::vector< T > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      void set_data(std::complex< T > & v, 
                    std::vector< std::complex< double > > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      std::vector< hsize_t > 
      get_extent(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      void set_extent(std::pair< T *, std::vector< std::size_t > > & v, 
                      std::vector< std::size_t > const & s);
    template<typename T> 
      std::vector< hsize_t > 
      get_offset(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      bool is_vectorizable(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      serializable_type< std::pair< T *, std::vector< std::size_t > > >::type const * 
      get_data(std::vector< typename serializable_type< std::pair< T *, std::vector< std::size_t > > >::type > & m, 
               std::pair< T *, std::vector< std::size_t > > const & v, 
               std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      void set_data(std::pair< T *, std::vector< std::size_t > > & v, 
                    std::vector< U > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      iarchive & call_serialize(iarchive & ar, std::string const & p, T & v);
    template<typename T> 
      oarchive & call_serialize(oarchive & ar, std::string const & p, 
                                T const & v);
    template<typename A, typename T> 
      A & serialize(A & ar, std::string const & p, T & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::complex< T > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::complex< T > const & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::deque< T > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::deque< T > const & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::pair< T *, std::vector< std::size_t > > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T, std::size_t N, typename A> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           boost::multi_array< T, N, A > & v);
    template<typename T, std::size_t N, typename A> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           boost::multi_array< T, N, A > const & v);
    template<typename T> 
      iarchive & operator>>(iarchive & ar, pvp< T > const & v);
    template<typename T> 
      oarchive & operator<<(oarchive & ar, pvp< T > const & v);
  }
}

Header <alps/lambda.hpp>

namespace boost {
  namespace lambda {
    template<typename Act, typename T> 
      struct plain_return_type_2<arithmetic_action< Act >, std::valarray< T >, std::valarray< T >>;
    template<typename Act, typename T, typename U> 
      struct plain_return_type_2<arithmetic_action< Act >, std::valarray< T >, U>;
    template<typename Act, typename T, typename U> 
      struct plain_return_type_2<arithmetic_action< Act >, U, std::valarray< T >>;
  }
}

Header <alps/lattice.h>

includes all headers in the alps/lattice directory

Header <alps/model.h>

includes all headers in the alps/model directory

extensions to boost::multi_array

This header defines some I/O extensions to boost::multi_array and fixes a problem with gcc-3.1 when alps::multi_array and alps::serialization are used together


access
namespace alps {

  // ALPS de-serialization support for boost::multi_array. 
  template<typename T, std::size_t NumDims, typename Allocator> 
    alps::IDump & 
    operator>>(alps::IDump & dump, 
               boost::multi_array< T, NumDims, Allocator > & x);

  // ALPS serialization support for boost::multi_array. 
  template<typename T, std::size_t NumDims, typename Allocator> 
    alps::ODump & 
    operator<<(alps::ODump & dump, 
               const boost::multi_array< T, NumDims, Allocator > & x);
}

// writes a two-dimensional boost::multi_array to an output stream 
template<typename T, typename Allocator> 
  std::ostream & 
  operator<<(std::ostream & out, 
             const boost::multi_array< T, 2, Allocator > & x);

// writes a four-dimensional boost::multi_array to an output stream 
template<typename T, typename Allocator> 
  std::ostream & 
  operator<<(std::ostream & out, 
             const boost::multi_array< T, 4, Allocator > & x);

Header <alps/ngs.hpp>

namespace alps {
  class mcoptions;
  class mcparamvalue;
  class mcparams;
  class mcany;
  template<typename T> class mcdata;

  template<typename S> struct result_names_type;
  template<typename S> struct results_type;
  template<typename S> struct parameters_type;

  class mcbase;
  class mcdeprecated;
  template<typename T> class mcatomic;
  template<typename Impl> class mcthreadedsim;
  template<typename Impl> class mcmpisim;

  typedef unspecified mcsignal;
  template<typename T> unspecified short_print(T const & v);
  template<typename T> 
    std::ostream & operator<<(std::ostream & os, unspecified v);
  template<typename T> 
    std::ostream & operator<<(std::ostream & os, unspecified v);
  std::ostream & 
  operator<<(std::ostream & os, 
             boost::ptr_map< std::string, mcany > const & results);
  template<typename S> result_names_type< S >::type result_names(S const & s);
  template<typename S> 
    result_names_type< S >::type unsaved_result_names(S const & s);
  template<typename S> results_type< S >::type collect_results(S const & s);
  template<typename S> 
    results_type< S >::type 
    collect_results(S const & s, 
                    typename result_names_type< S >::type const & names);
  template<typename S> 
    results_type< S >::type 
    collect_results(S const & s, std::string const & name);
  template<typename S> double fraction_completed(S const & s);
  template<typename R, typename P> 
    void save_results(R const & results, P const & params, 
                      boost::filesystem::path const & filename, 
                      std::string const & path);
}namespace boost {
  namespace mpi {
    template<typename T, typename Op> 
      void reduce(const communicator & comm, 
                  std::vector< T > const & in_values, Op op, int root);
    template<typename T, typename Op> 
      void reduce(const communicator & comm, 
                  std::vector< T > const & in_values, 
                  std::vector< T > & out_values, Op op, int root);
  }
}

Header <alps/osiris.h>

includes all headers in the alps/osiris directory

Header <alps/plot.h>

classes to create plots in XML format

This header contains classes to create plots in XML format, compatible with the ALPS XML schema for plot files on the http://xml.comp-phys.org/ web page

namespace alps {
  namespace plot {
    template<typename C> class Point;
    template<typename C> class Set;
    template<typename C> class Plot;

    enum SetType;

    // write a plot to an XML file following the ALPS XML schema for plots on http://xml.comp-phys.org/
    template<typename C> 
      oxstream & operator<<(oxstream & out, const Plot< C > & p);
    template<typename C> 
      oxstream & operator<<(oxstream & o, const Set< C > & S);
  }
}

Header <alps/random.h>

includes all headers in the alps/random directory

implements a string class that can easily be assigned to and converted to any type

namespace alps {
  template<typename StringBase> class lexical_cast_string;

  typedef lexical_cast_string StringValue;  // StringValue is now implemented using lexical_cast_string. 
}

Header <alps/xml.h>

includes all headers in the alps/parser directory

Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext