![]() |
Home | Libraries | License | Support | People | ALPS Web Site |
includes all headers in the alps/alea directory
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
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 >>; }
_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); } }
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 >>; } }
includes all headers in the alps/lattice directory
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);
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); } }
includes all headers in the alps/osiris directory
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); } }
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. }
includes all headers in the alps/parser directory
Copyright © 1994, 2002-2005 Matthias Troyer, Synge Todo |