Reference

Summary

Members	Descriptions
`namespace` `alps`
`namespace` `alps::detail`
`namespace` `alps::numeric`
`class` `alps::integer_state::reference`
`class` `alps::integer_state< I, 1 >::reference`
`struct` `alps::half_integer::to_distinguish`

namespace `alps`

Summary

Members	Descriptions
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::site_basis_match< I > & q)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BasisDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis_match< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BasisDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::basis_states< I, S, SS > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::lookup_basis_states< I, J, S, SS > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::bloch_basis_states< I, S, SS > & q)`
`public template<>` `multi_array< std::pair< T, bool >, 4 >` `get_fermionic_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor< I > & basis1,const` `SiteBasisDescriptor< I > & basis2,const Parameters & p)`
`public template<>` `multi_array< T, 4 >` `get_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor< I > & basis1,const` `SiteBasisDescriptor< I > & basis2,const Parameters & p)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondOperator` `& q)`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondOperator` `& q)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondTermDescriptor` `& q)`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondTermDescriptor` `& q)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::GlobalOperator` `& q)`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::GlobalOperator` `& q)`
`public template<>` `inline double` `to_double(const` `half_integer< I > & x)`
`public template<>` `inline I` `to_integer(const` `half_integer< I > & x)`
`public template<>` `inline bool` `is_odd(T x)`
`public template<>` `inline bool` `is_odd(const` `half_integer< I > & x)`
`public template<>` `inline` `half_integer< I >` `abs(const` `half_integer< I > & x)`
`public template<>` `inline bool` `operator==(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline bool` `operator!=(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline bool` `operator<(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline bool` `operator>(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline bool` `operator<=(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline bool` `operator>=(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline` `alps::half_integer< I >` `operator+(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline` `alps::half_integer< I >` `operator-(double x,const` `alps::half_integer< I > & y)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & os,const` `alps::half_integer< I > & x)`
`public template<>` `inline std::istream &` `operator>>(std::istream & is,alps::half_integer< I > & x)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::HamiltonianDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::HamiltonianDescriptor< I > & q)`
`public template<>` `bool` `operator==(integer_state< I, N > x,integer_state< I, N > y)`
`public template<>` `bool` `operator<(integer_state< I, N > x,integer_state< I, N > y)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & os,const` `alps::ModelLibrary` `& l)`
`public inline std::ostream &` `operator<<(std::ostream & os,const` `alps::ModelLibrary` `& l)`
`public inline std::istream &` `operator>>(std::istream & is,alps::ModelLibrary` `& l)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::OperatorDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::OperatorDescriptor< I > & q)`
`public template<>` `inline bool` `operator<(const` `QuantumNumberDescriptor< I > & q1,const` `QuantumNumberDescriptor< I > & q2)`
`public template<>` `QuantumNumberDescriptor< I >` `operator+(const` `QuantumNumberDescriptor< I > & x,const` `QuantumNumberDescriptor< I > & y)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::QuantumNumberDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::QuantumNumberDescriptor< I > & q)`
`public template<>` `bool` `is_frustrated(const G & graph,B bond_map)`
`public template<>` `bool` `is_frustrated(const G & graph,B bond_map,S site_map)`
`public template<>` `bool` `has_sign_problem(const` `HamiltonianDescriptor< I > & ham,const graph_helper< G > & lattice,const Parameters & p)`
`public template<>` `inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteBasisDescriptor< I > & q)`
`public template<>` `inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteBasisDescriptor< I > & q)`
`public template<>` `bool` `is_fermionic(const` `site_basis< I, STATE > & b,int s)`
`public template<>` `std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis< I, STATE > & s)`
`public template<>` `inline multi_array< std::pair< T, bool >, 2 >` `get_fermionic_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p)`
`public template<>` `multi_array< T, 2 >` `get_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p,bool ignore_fermion)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteOperator` `& q)`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteOperator` `& q)`
`public template<>` `bool` `operator<(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`
`public template<>` `bool` `operator>(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`
`public template<>` `bool` `operator==(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`
`public template<>` `bool` `operator<=(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`
`public template<>` `bool` `operator>=(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`
`public template<>` `half_integer< I >` `get_quantumnumber(const` `site_state< I > & s,typename` `site_state< I >::size_type i)`
`public template<>` `half_integer< I >` `get_quantumnumber(const` `single_qn_site_state< I > & s,std::size_t i)`
`public template<>` `half_integer< I > &` `get_quantumnumber(site_state< I > & s,typename` `site_state< I >::size_type i)`
`public template<>` `half_integer< I > &` `get_quantumnumber(single_qn_site_state< I > & s,std::size_t i)`
`public template<>` `std::size_t` `get_quantumnumber_index(const std::string & n,const` `SiteBasisDescriptor< I > & b)`
`public template<>` `S::quantumnumber_type` `get_quantumnumber(const S & s,const std::string & n,const` `SiteBasisDescriptor< I > & b)`
`public template<>` `bool` `is_fermionic(const` `SiteBasisDescriptor< I > & b,const S & s)`
`public template<>` `std::ostream &` `operator<<(std::ostream & out,const` `alps::site_state< I > & s)`
`public template<>` `std::ostream &` `operator<<(std::ostream & out,const` `alps::single_qn_site_state< I > & s)`
`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteTermDescriptor` `& q)`
`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteTermDescriptor` `& q)`
`public inline std::string` `substitute(std::string const & text,unsigned int type)`
`public inline Parameters` `substitute(Parameters const & parms,unsigned int type)`
`class` `alps::basis_states`
`class` `alps::basis_states_descriptor`
`class` `alps::BasisDescriptor`
`class` `alps::bloch_basis_states`
`class` `alps::BondOperator`
`class` `alps::BondOperatorEvaluator`
`class` `alps::BondOperatorSplitter`
`class` `alps::BondTermDescriptor`
`class` `alps::DefaultTermDescriptor`
`class` `alps::GlobalOperator`
`class` `alps::half_integer`
`class` `alps::hamiltonian_matrix`
`class` `alps::HamiltonianDescriptor`
`class` `alps::integer_state`
`class` `alps::integer_state< I, 1 >`
`class` `alps::lookup_basis_states`
`class` `alps::model_helper`
`class` `alps::ModelLibrary`
`class` `alps::OperatorDescriptor`
`class` `alps::OperatorEvaluator`
`class` `alps::OperatorSubstitution`
`class` `alps::QuantumNumberDescriptor`
`class` `alps::single_qn_site_state`
`class` `alps::site_basis`
`class` `alps::site_basis_match`
`class` `alps::site_state`
`class` `alps::SiteBasisDescriptor`
`class` `alps::SiteOperator`
`class` `alps::SiteOperatorEvaluator`
`class` `alps::SiteOperatorSplitter`
`class` `alps::SiteTermDescriptor`
`struct` `alps::nonzero_edge_weight`

Members

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::site_basis_match & q)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BasisDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis_match & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BasisDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::basis_states< I, S, SS > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::lookup_basis_states< I, J, S, SS > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::bloch_basis_states< I, S, SS > & q)`

`public template<>`
`multi_array< std::pair< T, bool >, 4 >` `get_fermionic_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor & basis1,const` `SiteBasisDescriptor & basis2,const Parameters & p)`

`public template<>`
`multi_array< T, 4 >` `get_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor & basis1,const` `SiteBasisDescriptor & basis2,const Parameters & p)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondOperator` `& q)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondTermDescriptor` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondTermDescriptor` `& q)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::GlobalOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::GlobalOperator` `& q)`

`public template<>`
`inline double` `to_double(const` `half_integer & x)`

`public template<>`
`inline I` `to_integer(const` `half_integer & x)`

`public template<>`
`inline bool` `is_odd(T x)`

`public template<>`
`inline bool` `is_odd(const` `half_integer & x)`

`public template<>`
`inline` `half_integer` `abs(const` `half_integer & x)`

`public template<>`
`inline bool` `operator==(double x,const` `alps::half_integer & y)`

`public template<>`
`inline bool` `operator!=(double x,const` `alps::half_integer & y)`

`public template<>`
`inline bool` `operator<(double x,const` `alps::half_integer & y)`

`public template<>`
`inline bool` `operator>(double x,const` `alps::half_integer & y)`

`public template<>`
`inline bool` `operator<=(double x,const` `alps::half_integer & y)`

`public template<>`
`inline bool` `operator>=(double x,const` `alps::half_integer & y)`

`public template<>`
`inline` `alps::half_integer` `operator+(double x,const` `alps::half_integer & y)`

`public template<>`
`inline` `alps::half_integer` `operator-(double x,const` `alps::half_integer & y)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & os,const` `alps::half_integer & x)`

`public template<>`
`inline std::istream &` `operator>>(std::istream & is,alps::half_integer & x)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::HamiltonianDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::HamiltonianDescriptor & q)`

`public template<>`
`bool` `operator==(integer_state< I, N > x,integer_state< I, N > y)`

`public template<>`
`bool` `operator<(integer_state< I, N > x,integer_state< I, N > y)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & os,const` `alps::ModelLibrary` `& l)`

`public inline std::ostream &` `operator<<(std::ostream & os,const` `alps::ModelLibrary` `& l)`

`public inline std::istream &` `operator>>(std::istream & is,alps::ModelLibrary` `& l)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::OperatorDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::OperatorDescriptor & q)`

`public template<>`
`inline bool` `operator<(const` `QuantumNumberDescriptor & q1,const` `QuantumNumberDescriptor & q2)`

`public template<>`
`QuantumNumberDescriptor` `operator+(const` `QuantumNumberDescriptor & x,const` `QuantumNumberDescriptor & y)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::QuantumNumberDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::QuantumNumberDescriptor & q)`

`public template<>`
`bool` `is_frustrated(const G & graph,B bond_map)`

`public template<>`
`bool` `is_frustrated(const G & graph,B bond_map,S site_map)`

`public template<>`
`bool` `has_sign_problem(const` `HamiltonianDescriptor & ham,const graph_helper< G > & lattice,const Parameters & p)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteBasisDescriptor & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteBasisDescriptor & q)`

`public template<>`
`bool` `is_fermionic(const` `site_basis< I, STATE > & b,int s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis< I, STATE > & s)`

`public template<>`
`inline multi_array< std::pair< T, bool >, 2 >` `get_fermionic_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor & basis1,const Parameters & p)`

`public template<>`
`multi_array< T, 2 >` `get_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor & basis1,const Parameters & p,bool ignore_fermion)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteOperator` `& q)`

`public template<>`
`bool` `operator<(const` `single_qn_site_state & x,const` `single_qn_site_state & y)`

`public template<>`
`bool` `operator>(const` `single_qn_site_state & x,const` `single_qn_site_state & y)`

`public template<>`
`bool` `operator==(const` `single_qn_site_state & x,const` `single_qn_site_state & y)`

`public template<>`
`bool` `operator<=(const` `single_qn_site_state & x,const` `single_qn_site_state & y)`

`public template<>`
`bool` `operator>=(const` `single_qn_site_state & x,const` `single_qn_site_state & y)`

`public template<>`
`half_integer` `get_quantumnumber(const` `site_state & s,typename` `site_state::size_type i)`

`public template<>`
`half_integer` `get_quantumnumber(const` `single_qn_site_state & s,std::size_t i)`

`public template<>`
`half_integer &` `get_quantumnumber(site_state & s,typename` `site_state::size_type i)`

`public template<>`
`half_integer &` `get_quantumnumber(single_qn_site_state & s,std::size_t i)`

`public template<>`
`std::size_t` `get_quantumnumber_index(const std::string & n,const` `SiteBasisDescriptor & b)`

`public template<>`
`S::quantumnumber_type` `get_quantumnumber(const S & s,const std::string & n,const` `SiteBasisDescriptor & b)`

`public template<>`
`bool` `is_fermionic(const` `SiteBasisDescriptor & b,const S & s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::site_state & s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::single_qn_site_state & s)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteTermDescriptor` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteTermDescriptor` `& q)`

`public inline std::string` `substitute(std::string const & text,unsigned int type)`

`public inline Parameters` `substitute(Parameters const & parms,unsigned int type)`

class `alps::basis_states`

class alps::basis_states
  : public std::vector< std::vector< I > >

Summary

Members	Descriptions
`public inline` `basis_states()`
`public template<>` `inline` `basis_states(const` `basis_states_descriptor< I, SS > & b,const std::vector< std::pair< std::string,` `half_integer< J > > > & c)`
`public inline` `basis_states(const` `basis_states_descriptor< I, SS > & b)`
`public inline std::size_t` `index(const value_type & x) const`
`public inline std::pair< std::size_t, std::complex< double > >` `index_and_phase(const value_type & x) const`
`public inline double` `normalization(size_type) const`
`public inline bool` `is_real() const`
`public bool` `check_sort() const`
`public inline const` `basis_type&basis() const`
`typedef` `const_iterator`
`typedef` `value_type`
`typedef` `size_type`
`typedef` `basis_type`

Members

`public inline` `basis_states()`

`public template<>`
`inline` `basis_states(const` `basis_states_descriptor< I, SS > & b,const std::vector< std::pair< std::string,` `half_integer< J > > > & c)`

`public inline` `basis_states(const` `basis_states_descriptor< I, SS > & b)`

`public inline std::size_t` `index(const value_type & x) const`

`public inline std::pair< std::size_t, std::complex< double > >` `index_and_phase(const value_type & x) const`

`public inline double` `normalization(size_type) const`

`public inline bool` `is_real() const`

`public bool` `check_sort() const`

`public inline const` `basis_type&basis() const`

`typedef` `const_iterator`

`typedef` `value_type`

`typedef` `size_type`

`typedef` `basis_type`

class `alps::basis_states_descriptor`

class alps::basis_states_descriptor
  : public std::vector< site_basis< I, site_state< I > > >

Summary

Members	Descriptions
`public inline` `basis_states_descriptor()`
`public template<>` `basis_states_descriptor(const` `BasisDescriptor< I > & b,const G & graph)`
`public inline const` `BasisDescriptor< I > &` `get_basis() const`
`public inline const` `SiteBasisDescriptor< I > &` `get_site_basis(int i) const`
`public inline bool` `set_parameters(const Parameters & p)`
`typedef` `site_basis_type`
`typedef` `const_iterator`

Members

`public inline` `basis_states_descriptor()`

`public template<>`
`basis_states_descriptor(const` `BasisDescriptor & b,const G & graph)`

`public inline const` `BasisDescriptor &` `get_basis() const`

`public inline const` `SiteBasisDescriptor &` `get_site_basis(int i) const`

`public inline bool` `set_parameters(const Parameters & p)`

`typedef` `site_basis_type`

`typedef` `const_iterator`

class `alps::BasisDescriptor`

class alps::BasisDescriptor
  : private std::vector< site_basis_match< I > >

Summary

Members	Descriptions
`public inline` `BasisDescriptor(const std::string & name)`
`public` `BasisDescriptor(const XMLTag &,std::istream &,const sitebasis_map_type & bases_)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `name() const`
`public bool` `set_parameters(const Parameters & p)`
`public inline const constraints_type &` `constraints() const`
`public inline const unevaluated_constraints_type &` `unevaluated_constraints() const`
`public inline const unevaluated_constraints_type &` `all_constraints() const`
`public const` `SiteBasisDescriptor< I > &` `site_basis(int type) const`
`public const_iterator` `create_site_basis(int type)`
`public template<>` `inline void` `create_site_bases(graph_helper< G > const & l)`
`typedef` `iterator`
`typedef` `const_iterator`
`typedef` `sitebasis_map_type`
`typedef` `constraints_type`
`typedef` `expression_type`
`typedef` `unevaluated_constraints_type`

Members

`public inline` `BasisDescriptor(const std::string & name)`

`public` `BasisDescriptor(const XMLTag &,std::istream &,const sitebasis_map_type & bases_)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `name() const`

`public bool` `set_parameters(const Parameters & p)`

`public inline const constraints_type &` `constraints() const`

`public inline const unevaluated_constraints_type &` `unevaluated_constraints() const`

`public inline const unevaluated_constraints_type &` `all_constraints() const`

`public const` `SiteBasisDescriptor &` `site_basis(int type) const`

`public const_iterator` `create_site_basis(int type)`

`public template<>`
`inline void` `create_site_bases(graph_helper< G > const & l)`

`typedef` `iterator`

`typedef` `const_iterator`

`typedef` `sitebasis_map_type`

`typedef` `constraints_type`

`typedef` `expression_type`

`typedef` `unevaluated_constraints_type`

class `alps::bloch_basis_states`

class alps::bloch_basis_states
  : public std::vector< std::vector< I > >

Summary

Members	Descriptions
`public inline` `bloch_basis_states()`
`public template<>` `inline` `bloch_basis_states(const` `basis_states_descriptor< I, SS > & b,const translation_type & t,const std::vector< std::pair< std::string,` `half_integer< J > > > & c)`
`public inline` `bloch_basis_states(const` `basis_states_descriptor< I, SS > & b,const translation_type & t)`
`public inline std::pair< std::size_t, std::complex< double > >` `index_and_phase(const value_type & x) const`
`public inline const` `basis_type&basis() const`
`public inline double` `normalization(size_type i) const`
`public inline bool` `is_real() const`
`public inline std::vector< S > &` `full_list()`
`typedef` `const_iterator`
`typedef` `value_type`
`typedef` `size_type`
`typedef` `basis_type`
`typedef` `translation_type`

Members

`public inline` `bloch_basis_states()`

`public template<>`
`inline` `bloch_basis_states(const` `basis_states_descriptor< I, SS > & b,const translation_type & t,const std::vector< std::pair< std::string,` `half_integer< J > > > & c)`

`public inline` `bloch_basis_states(const` `basis_states_descriptor< I, SS > & b,const translation_type & t)`

`public inline std::pair< std::size_t, std::complex< double > >` `index_and_phase(const value_type & x) const`

`public inline const` `basis_type&basis() const`

`public inline double` `normalization(size_type i) const`

`public inline bool` `is_real() const`

`public inline std::vector< S > &` `full_list()`

`typedef` `const_iterator`

`typedef` `value_type`

`typedef` `size_type`

`typedef` `basis_type`

`typedef` `translation_type`

class `alps::BondOperator`

Summary

Members	Descriptions
`public inline` `BondOperator()`
`public inline` `BondOperator(const std::string & s,const std::string & t)`
`public inline` `BondOperator(const std::string & term,const std::string & s,const std::string & t)`
`public inline` `BondOperator(const XMLTag & tag,std::istream & in)`
`public inline` `BondOperator(BondOperator` `const & op,std::string const & t,Parameters const & p)`
`public void` `read_xml(const XMLTag &,std::istream &)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `name() const`
`public inline const std::string &` `term() const`
`public inline std::string &` `term()`
`public inline const std::string &` `source() const`
`public inline const std::string &` `target() const`
`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`
`public template<>` `multi_array< std::pair< T, bool >, 4 >` `matrix(const` `SiteBasisDescriptor< I > &,const` `SiteBasisDescriptor< I > &,const Parameters &) const`
`public template<>` `std::vector< boost::tuple< expression::Term< T >,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >templated_split(SiteBasisDescriptor< I > const &,SiteBasisDescriptor< I > const &,const Parameters &) const`
`public template<>` `inline std::vector< boost::tuple< Term,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >split(SiteBasisDescriptor< I > const & b1,SiteBasisDescriptor< I > const & b2,const Parameters & p) const`
`public inline std::vector< boost::tuple< Term,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >split(const Parameters & p) const`
`public std::set< std::string >` `operator_names(const Parameters &) const`
`public inline Parameters const &` `parms() const`

Members

`public inline` `BondOperator()`

`public inline` `BondOperator(const std::string & s,const std::string & t)`

`public inline` `BondOperator(const std::string & term,const std::string & s,const std::string & t)`

`public inline` `BondOperator(const XMLTag & tag,std::istream & in)`

`public inline` `BondOperator(BondOperator` `const & op,std::string const & t,Parameters const & p)`

`public void` `read_xml(const XMLTag &,std::istream &)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `name() const`

`public inline const std::string &` `term() const`

`public inline std::string &` `term()`

`public inline const std::string &` `source() const`

`public inline const std::string &` `target() const`

`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`

`public template<>`
`multi_array< std::pair< T, bool >, 4 >` `matrix(const` `SiteBasisDescriptor &,const` `SiteBasisDescriptor &,const Parameters &) const`

`public template<>`
`std::vector< boost::tuple< expression::Term< T >,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >templated_split(SiteBasisDescriptor const &,SiteBasisDescriptor const &,const Parameters &) const`

`public template<>`
`inline std::vector< boost::tuple< Term,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >split(SiteBasisDescriptor const & b1,SiteBasisDescriptor const & b2,const Parameters & p) const`

`public inline std::vector< boost::tuple< Term,` `SiteOperator](#d7/d82/classalps_1_1_site_operator), [SiteOperator> >split(const Parameters & p) const`

`public std::set< std::string >` `operator_names(const Parameters &) const`

`public inline Parameters const &` `parms() const`

class `alps::BondOperatorEvaluator`

class alps::BondOperatorEvaluator
  : public alps::OperatorEvaluator< T >

Summary

Members	Descriptions
`public inline` `BondOperatorEvaluator(const STATE1 & s1,const STATE2 & s2,const` `SiteBasisDescriptor< I > & b1,const` `SiteBasisDescriptor< I > & b2,const std::string & site1,const std::string & site2,const Parameters & p)`
`public inline` `BondOperatorEvaluator(const` `SiteOperatorEvaluator< I, T, STATE1 > & s1,const` `SiteOperatorEvaluator< I, T, STATE2 > & s2,const Parameters & p)`
`public bool` `can_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`
`public inline std::pair< STATE1, STATE2 >` `state() const`
`public inline bool` `fermionic() const`
`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`

Members

`public inline` `BondOperatorEvaluator(const STATE1 & s1,const STATE2 & s2,const` `SiteBasisDescriptor & b1,const` `SiteBasisDescriptor & b2,const std::string & site1,const std::string & site2,const Parameters & p)`

`public inline` `BondOperatorEvaluator(const` `SiteOperatorEvaluator< I, T, STATE1 > & s1,const` `SiteOperatorEvaluator< I, T, STATE2 > & s2,const Parameters & p)`

`public bool` `can_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`

`public inline std::pair< STATE1, STATE2 >` `state() const`

`public inline bool` `fermionic() const`

`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`

class `alps::BondOperatorSplitter`

class alps::BondOperatorSplitter
  : public alps::OperatorEvaluator< std::complex< double > >

Summary

Members	Descriptions
`public inline` `BondOperatorSplitter(const` `SiteBasisDescriptor< I > & b1,const` `SiteBasisDescriptor< I > & b2,const std::string & site1,const std::string & site2,const Parameters & p)`
`public bool` `can_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`
`public inline const std::pair< expression::Term< T >, expression::Term< T > > &` `site_operators() const`
`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`

Members

`public inline` `BondOperatorSplitter(const` `SiteBasisDescriptor & b1,const` `SiteBasisDescriptor & b2,const std::string & site1,const std::string & site2,const Parameters & p)`

`public bool` `can_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`

`public inline const std::pair< expression::Term< T >, expression::Term< T > > &` `site_operators() const`

`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`

class `alps::BondTermDescriptor`

class alps::BondTermDescriptor
  : public alps::BondOperator

Summary

Members	Descriptions
`public inline` `BondTermDescriptor()`
`public inline` `BondTermDescriptor(const std::string & s,const std::string & t)`
`public inline` `BondTermDescriptor(const std::string & term,const std::string & s,const std::string & t)`
`public` `BondTermDescriptor(const XMLTag &,std::istream &)`
`public inline` `BondTermDescriptor(BondTermDescriptor` `const & t,std::string const & term,Parameters const & p,unsigned int type)`
`public inline const` `BondOperator&bond_operator() const`
`public void` `write_xml(oxstream &) const`
`public inline bool` `match_type(int type) const`

Members

`public inline` `BondTermDescriptor()`

`public inline` `BondTermDescriptor(const std::string & s,const std::string & t)`

`public inline` `BondTermDescriptor(const std::string & term,const std::string & s,const std::string & t)`

`public` `BondTermDescriptor(const XMLTag &,std::istream &)`

`public inline` `BondTermDescriptor(BondTermDescriptor` `const & t,std::string const & term,Parameters const & p,unsigned int type)`

`public inline const` `BondOperator&bond_operator() const`

`public void` `write_xml(oxstream &) const`

`public inline bool` `match_type(int type) const`

class `alps::DefaultTermDescriptor`

class alps::DefaultTermDescriptor
  : public TERM

Summary

Members	Descriptions
`public inline` `DefaultTermDescriptor()`
`public inline` `DefaultTermDescriptor(const XMLTag & tag,std::istream & in)`
`public term_type` `get(unsigned int type) const`
`public inline Parameters` `parms(unsigned int type) const`
`typedef` `term_type`

Members

`public inline` `DefaultTermDescriptor()`

`public inline` `DefaultTermDescriptor(const XMLTag & tag,std::istream & in)`

`public term_type` `get(unsigned int type) const`

`public inline Parameters` `parms(unsigned int type) const`

`typedef` `term_type`

class `alps::GlobalOperator`

Summary

Members	Descriptions
`public inline` `GlobalOperator()`
`public` `GlobalOperator(const XMLTag &,std::istream &)`
`public XMLTag` `read_xml(const XMLTag &,std::istream &)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `name() const`
`public inline const std::vector<` `SiteTermDescriptor> &site_terms() const`
`public inline const std::vector<` `BondTermDescriptor> &bond_terms() const`
`public` `SiteOperator` `site_term(unsigned int type) const`
`public` `BondOperator` `bond_term(unsigned int type) const`
`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`
`public boost::optional< Parameters >` `create_site_term(unsigned int type)`
`public boost::optional< Parameters >` `create_bond_term(unsigned int type)`
`public template<>` `inline Parameters` `create_terms(graph_helper< G > const & l)`
`protected void` `write_operators_xml(oxstream &) const`

Members

`public inline` `GlobalOperator()`

`public` `GlobalOperator(const XMLTag &,std::istream &)`

`public XMLTag` `read_xml(const XMLTag &,std::istream &)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `name() const`

`public inline const std::vector<` `SiteTermDescriptor> &site_terms() const`

`public inline const std::vector<` `BondTermDescriptor> &bond_terms() const`

`public` `SiteOperator` `site_term(unsigned int type) const`

`public` `BondOperator` `bond_term(unsigned int type) const`

`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`

`public boost::optional< Parameters >` `create_site_term(unsigned int type)`

`public boost::optional< Parameters >` `create_bond_term(unsigned int type)`

`public template<>`
`inline Parameters` `create_terms(graph_helper< G > const & l)`

`protected void` `write_operators_xml(oxstream &) const`

class `alps::half_integer`

Summary

Members	Descriptions
`public inline` `half_integer()`
`public template<>` `inline` `half_integer(const` `half_integer< J > & x)`
`public template<>` `inline` `half_integer(J x,typename boost::enable_if< boost::is_integral< J > >::type *)`
`public template<>` `inline` `half_integer(J x,typename boost::enable_if< boost::mpl::and_< boost::is_float< J >, boost::mpl::not_< boost::is_same< J, double > > > >::type *)`
`public inline` `half_integer(double x)`
`public inline double` `to_double() const`
`public inline integer_type` `to_integer() const`
`public inline void` `set_half(integer_type x)`
`public inline integer_type` `get_twice() const`
`public inline bool` `is_odd() const`
`public inline bool` `is_even() const`
`public template<>` `inline bool` `operator==(const` `half_integer< J > & rhs) const`
`public template<>` `inline bool` `operator!=(const` `half_integer< J > & rhs) const`
`public template<>` `inline bool` `operator<(const` `half_integer< J > & rhs) const`
`public template<>` `inline bool` `operator>(const` `half_integer< J > & rhs) const`
`public template<>` `inline bool` `operator<=(const` `half_integer< J > & rhs) const`
`public template<>` `inline bool` `operator>=(const` `half_integer< J > & rhs) const`
`public inline bool` `operator==(double rhs) const`
`public inline bool` `operator!=(double rhs) const`
`public inline bool` `operator<(double rhs) const`
`public inline bool` `operator>(double rhs) const`
`public inline bool` `operator<=(double rhs) const`
`public inline bool` `operator>=(double rhs) const`
`public inline` `half_integer` `operator-() const`
`public inline` `half_integer&operator++()`
`public inline` `half_integer&operator--()`
`public inline` `half_integer` `operator++(int)`
`public inline` `half_integer` `operator--(int)`
`public template<>` `inline` `half_integer&operator+=(const` `half_integer< J > & x)`
`public template<>` `inline` `half_integer&operator-=(const` `half_integer< J > & x)`
`public inline` `half_integer&operator+=(double x)`
`public inline` `half_integer&operator-=(double x)`
`public template<>` `inline` `half_integer` `operator+(const` `half_integer< J > & x) const`
`public template<>` `inline` `half_integer` `operator-(const` `half_integer< J > & x) const`
`public inline` `half_integer` `operator+(double x) const`
`public inline` `half_integer` `operator-(double x) const`
`public inline integer_type` `distance(const` `half_integer` `& x) const`
`public inline` `half_integer` `abs() const`
`typedef` `integer_type`

Members

`public inline` `half_integer()`

`public template<>`
`inline` `half_integer(const` `half_integer< J > & x)`

`public template<>`
`inline` `half_integer(J x,typename boost::enable_if< boost::is_integral< J > >::type *)`

`public template<>`
`inline` `half_integer(J x,typename boost::enable_if< boost::mpl::and_< boost::is_float< J >, boost::mpl::not_< boost::is_same< J, double > > > >::type *)`

`public inline` `half_integer(double x)`

`public inline double` `to_double() const`

`public inline integer_type` `to_integer() const`

`public inline void` `set_half(integer_type x)`

`public inline integer_type` `get_twice() const`

`public inline bool` `is_odd() const`

`public inline bool` `is_even() const`

`public template<>`
`inline bool` `operator==(const` `half_integer< J > & rhs) const`

`public template<>`
`inline bool` `operator!=(const` `half_integer< J > & rhs) const`

`public template<>`
`inline bool` `operator<(const` `half_integer< J > & rhs) const`

`public template<>`
`inline bool` `operator>(const` `half_integer< J > & rhs) const`

`public template<>`
`inline bool` `operator<=(const` `half_integer< J > & rhs) const`

`public template<>`
`inline bool` `operator>=(const` `half_integer< J > & rhs) const`

`public inline bool` `operator==(double rhs) const`

`public inline bool` `operator!=(double rhs) const`

`public inline bool` `operator<(double rhs) const`

`public inline bool` `operator>(double rhs) const`

`public inline bool` `operator<=(double rhs) const`

`public inline bool` `operator>=(double rhs) const`

`public inline` `half_integer` `operator-() const`

`public inline` `half_integer&operator++()`

`public inline` `half_integer&operator--()`

`public inline` `half_integer` `operator++(int)`

`public inline` `half_integer` `operator--(int)`

`public template<>`
`inline` `half_integer&operator+=(const` `half_integer< J > & x)`

`public template<>`
`inline` `half_integer&operator-=(const` `half_integer< J > & x)`

`public inline` `half_integer&operator+=(double x)`

`public inline` `half_integer&operator-=(double x)`

`public template<>`
`inline` `half_integer` `operator+(const` `half_integer< J > & x) const`

`public template<>`
`inline` `half_integer` `operator-(const` `half_integer< J > & x) const`

`public inline` `half_integer` `operator+(double x) const`

`public inline` `half_integer` `operator-(double x) const`

`public inline integer_type` `distance(const` `half_integer` `& x) const`

`public inline` `half_integer` `abs() const`

`typedef` `integer_type`

class `alps::hamiltonian_matrix`

Summary

Members	Descriptions
`public` `hamiltonian_matrix(Parameters const & parms)`
`public inline void` `set_parameters(Parameters const & p)`
`public inline` `basis_states_type&states_vector()`
`public inline const` `basis_states_type&states_vector() const`
`public inline` `bloch_basis_states_type&bloch_states_vector()`
`public inline const` `bloch_basis_states_type&bloch_states_vector() const`
`public inline matrix_type &` `matrix()`
`public inline const matrix_type &` `matrix() const`
`public inline std::size_t` `dimension() const`
`public void` `dostep()`
`public inline void` `print_basis(std::ostream & os) const`
`public template<>` `void` `apply_operator(const STATES &,const` `SiteOperator` `& op,site_descriptor s,const V &,W &) const`
`public template<>` `inline void` `apply_operator(const` `SiteOperator` `& op,site_descriptor s,const V & x,W & y) const`
`public template<>` `void` `apply_operator(const` `BondOperator` `& op,bond_descriptor b,const V &,W &) const`
`public template<>` `void` `apply_operator(const` `BondOperator` `& op,site_descriptor s1,site_descriptor s2,const V &,W &) const`
`public template<>` `inline void` `apply_operator(const boost::multi_array< std::pair< value_type, bool >, 4 > & mat,site_descriptor s1,site_descriptor s2,const V & x,W & y) const`
`public template<>` `void` `apply_operator(const STATES &,const boost::multi_array< std::pair< value_type, bool >, 4 > & mat,site_descriptor s1,site_descriptor s2,const V & x,W & y) const`
`public template<>` `void` `apply_operator(const` `SiteOperator` `& op,const V &,W &) const`
`public template<>` `void` `apply_operator(const` `BondOperator` `& op,const V &,W &) const`
`public template<>` `void` `apply_operator(const` `GlobalOperator` `& op,const V &,W &) const`
`public template<>` `inline MM` `operator_matrix(const OP & op) const`
`public template<>` `inline void` `add_operator_matrix(MM & m,const OP & op) const`
`public template<>` `inline MM` `operator_matrix(const OP & op,D d) const`
`public template<>` `inline void` `add_operator_matrix(MM & m,const OP & op,D d) const`
`public template<>` `inline MM` `operator_matrix(const OP & op,site_descriptor s1,site_descriptor s2) const`
`public template<>` `inline void` `add_operator_matrix(MM & m,const OP & op,site_descriptor s1,site_descriptor s2) const`
`public multi_array< value_type, 2 >` `local_matrix(const` `SiteOperator` `& op,site_descriptor s) const`
`public multi_array< std::pair< value_type, bool >, 4 >` `local_matrix(const` `BondOperator` `& op,const bond_descriptor & b) const`
`public multi_array< std::pair< value_type, bool >, 4 >` `local_matrix(const` `BondOperator` `& op,const site_descriptor & s1,const site_descriptor & s2) const`
`public template<>` `inline void` `apply_operator(const std::string & name,bond_descriptor b,const V & x,W & y) const`
`public template<>` `void` `apply_operator(const std::string & op,site_descriptor s,const V & x,W & y) const`
`public template<>` `void` `apply_operator(const std::string & name,const V & x,W & y) const`
`public inline bool` `uses_translation_invariance() const`
`protected mutable` `basis_states_type` `states`
`protected mutable` `bloch_basis_states_type` `bloch_states`
`protected void` `build() const`
`protected void` `build_basis() const`
`typedef` `matrix_type`
`typedef` `value_type`
`typedef` `graph_type`
`typedef` `site_descriptor`
`typedef` `bond_descriptor`
`typedef` `site_iterator`
`typedef` `bond_iterator`
`typedef` `vector_type`
`typedef` `basis_descriptor_type`
`typedef` `basis_states_type`
`typedef` `bloch_basis_states_type`
`typedef` `state_type`

Members

`public` `hamiltonian_matrix(Parameters const & parms)`

`public inline void` `set_parameters(Parameters const & p)`

`public inline` `basis_states_type&states_vector()`

`public inline const` `basis_states_type&states_vector() const`

`public inline` `bloch_basis_states_type&bloch_states_vector()`

`public inline const` `bloch_basis_states_type&bloch_states_vector() const`

`public inline matrix_type &` `matrix()`

`public inline const matrix_type &` `matrix() const`

`public inline std::size_t` `dimension() const`

`public void` `dostep()`

`public inline void` `print_basis(std::ostream & os) const`

`public template<>`
`void` `apply_operator(const STATES &,const` `SiteOperator` `& op,site_descriptor s,const V &,W &) const`

`public template<>`
`inline void` `apply_operator(const` `SiteOperator` `& op,site_descriptor s,const V & x,W & y) const`

`public template<>`
`void` `apply_operator(const` `BondOperator` `& op,bond_descriptor b,const V &,W &) const`

`public template<>`
`void` `apply_operator(const` `BondOperator` `& op,site_descriptor s1,site_descriptor s2,const V &,W &) const`

`public template<>`
`inline void` `apply_operator(const boost::multi_array< std::pair< value_type, bool >, 4 > & mat,site_descriptor s1,site_descriptor s2,const V & x,W & y) const`

`public template<>`
`void` `apply_operator(const STATES &,const boost::multi_array< std::pair< value_type, bool >, 4 > & mat,site_descriptor s1,site_descriptor s2,const V & x,W & y) const`

`public template<>`
`void` `apply_operator(const` `SiteOperator` `& op,const V &,W &) const`

`public template<>`
`void` `apply_operator(const` `BondOperator` `& op,const V &,W &) const`

`public template<>`
`void` `apply_operator(const` `GlobalOperator` `& op,const V &,W &) const`

`public template<>`
`inline MM` `operator_matrix(const OP & op) const`

`public template<>`
`inline void` `add_operator_matrix(MM & m,const OP & op) const`

`public template<>`
`inline MM` `operator_matrix(const OP & op,D d) const`

`public template<>`
`inline void` `add_operator_matrix(MM & m,const OP & op,D d) const`

`public template<>`
`inline MM` `operator_matrix(const OP & op,site_descriptor s1,site_descriptor s2) const`

`public template<>`
`inline void` `add_operator_matrix(MM & m,const OP & op,site_descriptor s1,site_descriptor s2) const`

`public multi_array< value_type, 2 >` `local_matrix(const` `SiteOperator` `& op,site_descriptor s) const`

`public multi_array< std::pair< value_type, bool >, 4 >` `local_matrix(const` `BondOperator` `& op,const bond_descriptor & b) const`

`public multi_array< std::pair< value_type, bool >, 4 >` `local_matrix(const` `BondOperator` `& op,const site_descriptor & s1,const site_descriptor & s2) const`

`public template<>`
`inline void` `apply_operator(const std::string & name,bond_descriptor b,const V & x,W & y) const`

`public template<>`
`void` `apply_operator(const std::string & op,site_descriptor s,const V & x,W & y) const`

`public template<>`
`void` `apply_operator(const std::string & name,const V & x,W & y) const`

`public inline bool` `uses_translation_invariance() const`

`protected mutable` `basis_states_type` `states`

`protected mutable` `bloch_basis_states_type` `bloch_states`

`protected void` `build() const`

`protected void` `build_basis() const`

`typedef` `matrix_type`

`typedef` `value_type`

`typedef` `graph_type`

`typedef` `site_descriptor`

`typedef` `bond_descriptor`

`typedef` `site_iterator`

`typedef` `bond_iterator`

`typedef` `vector_type`

`typedef` `basis_descriptor_type`

`typedef` `basis_states_type`

`typedef` `bloch_basis_states_type`

`typedef` `state_type`

class `alps::HamiltonianDescriptor`

class alps::HamiltonianDescriptor
  : public alps::GlobalOperator

Summary

Members	Descriptions
`public inline` `HamiltonianDescriptor()`
`public` `HamiltonianDescriptor(const XMLTag &,std::istream &,const basis_map &,const operator_map &)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `name() const`
`public inline const` `BasisDescriptor< I > &` `basis() const`
`public inline` `BasisDescriptor< I > &` `basis()`
`public inline const Parameters &` `default_parameters() const`
`public bool` `set_parameters(Parameters p)`
`public template<>` `inline void` `create_terms(graph_helper< G > const & l)`
`typedef` `basis_map`
`typedef` `operator_map`

Members

`public inline` `HamiltonianDescriptor()`

`public` `HamiltonianDescriptor(const XMLTag &,std::istream &,const basis_map &,const operator_map &)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `name() const`

`public inline const` `BasisDescriptor &` `basis() const`

`public inline` `BasisDescriptor &` `basis()`

`public inline const Parameters &` `default_parameters() const`

`public bool` `set_parameters(Parameters p)`

`public template<>`
`inline void` `create_terms(graph_helper< G > const & l)`

`typedef` `basis_map`

`typedef` `operator_map`

class `alps::integer_state`

Summary

Members	Descriptions
`public` `BOOST_STATIC_CONSTANT(int,bits)`
`public` `BOOST_STATIC_CONSTANT(int,mask)`
`public inline` `integer_state(representation_type x)`
`public template<>` `inline` `integer_state(const std::vector< J > & x)`
`public inline int` `operator[](int i) const`
`public inline` `reference` `operator[](int i)`
`public inline` `operator representation_type() const`
`public inline representation_type` `state() const`
`typedef` `representation_type`

Members

`public` `BOOST_STATIC_CONSTANT(int,bits)`

`public` `BOOST_STATIC_CONSTANT(int,mask)`

`public inline` `integer_state(representation_type x)`

`public template<>`
`inline` `integer_state(const std::vector< J > & x)`

`public inline int` `operator[](int i) const`

`public inline` `reference` `operator[](int i)`

`public inline` `operator representation_type() const`

`public inline representation_type` `state() const`

`typedef` `representation_type`

class `alps::integer_state< I, 1 >`

Summary

Members	Descriptions
`public inline` `integer_state(representation_type x)`
`public template<>` `inline` `integer_state(const std::vector< J > & x)`
`public inline int` `operator[](int i) const`
`public inline` `reference` `operator[](int i)`
`public inline` `operator representation_type() const`
`public inline representation_type` `state() const`
`typedef` `representation_type`

Members

`public inline` `integer_state(representation_type x)`

`public template<>`
`inline` `integer_state(const std::vector< J > & x)`

`public inline int` `operator[](int i) const`

`public inline` `reference` `operator[](int i)`

`public inline` `operator representation_type() const`

`public inline representation_type` `state() const`

`typedef` `representation_type`

class `alps::lookup_basis_states`

class alps::lookup_basis_states
  : public alps::basis_states< short, integer_state< unsigned int >, basis_states_descriptor< short > >

Summary

Members	Descriptions
`public inline` `lookup_basis_states(const` `basis_states_descriptor< J, SS > & b)`
`public inline size_type` `index(const value_type & x) const`
`public inline std::pair< size_type, std::complex< double > >` `index_and_phase(const value_type & x) const`
`typedef` `const_iterator`
`typedef` `value_type`
`typedef` `size_type`
`typedef` `basis_type`

Members

`public inline` `lookup_basis_states(const` `basis_states_descriptor< J, SS > & b)`

`public inline size_type` `index(const value_type & x) const`

`public inline std::pair< size_type, std::complex< double > >` `index_and_phase(const value_type & x) const`

`typedef` `const_iterator`

`typedef` `value_type`

`typedef` `size_type`

`typedef` `basis_type`

class `alps::model_helper`

Summary

Members	Descriptions
`public inline` `model_helper(alps::Parameters const & p,bool issymbolic)`
`public template<>` `inline` `model_helper(alps::graph_helper< G > const & g,alps::Parameters const & p,bool issymbolic)`
`public inline const` `ModelLibrary&model_library() const`
`public inline` `HamiltonianDescriptor< I > &` `model()`
`public inline const` `HamiltonianDescriptor< I > &` `model() const`
`public inline` `basis_descriptor_type&basis()`
`public inline const` `basis_descriptor_type&basis() const`
`public inline const` `site_basis_descriptor_type&site_basis(int type) const`
`public inline` `SiteOperator` `site_term(int type) const`
`public inline` `BondOperator` `bond_term(int type) const`
`public inline bool` `has_site_operator(const std::string & name) const`
`public inline bool` `has_bond_operator(const std::string & name) const`
`public inline bool` `has_global_operator(const std::string & name) const`
`public inline bool` `has_operator(const std::string & name) const`
`public inline` `SiteOperator` `get_site_operator(const std::string & name,const Parameters & p) const`
`public inline` `BondOperator` `get_bond_operator(const std::string & name,const Parameters & p) const`
`public inline` `SiteOperator` `get_site_operator(const std::string & name) const`
`public inline` `BondOperator` `get_bond_operator(const std::string & name) const`
`public inline` `GlobalOperator` `get_global_operator(const std::string & name) const`
`public template<>` `inline void` `substitute_operators(OP & op,const Parameters & p) const`
`public inline std::set< std::string >` `quantum_numbers(int type)`
`typedef` `basis_descriptor_type`
`typedef` `site_basis_descriptor_type`
`typedef` `half_integer_type`
`typedef` `quantum_number_type`

Members

`public inline` `model_helper(alps::Parameters const & p,bool issymbolic)`

`public template<>`
`inline` `model_helper(alps::graph_helper< G > const & g,alps::Parameters const & p,bool issymbolic)`

`public inline const` `ModelLibrary&model_library() const`

`public inline` `HamiltonianDescriptor &` `model()`

`public inline const` `HamiltonianDescriptor &` `model() const`

`public inline` `basis_descriptor_type&basis()`

`public inline const` `basis_descriptor_type&basis() const`

`public inline const` `site_basis_descriptor_type&site_basis(int type) const`

`public inline` `SiteOperator` `site_term(int type) const`

`public inline` `BondOperator` `bond_term(int type) const`

`public inline bool` `has_site_operator(const std::string & name) const`

`public inline bool` `has_bond_operator(const std::string & name) const`

`public inline bool` `has_global_operator(const std::string & name) const`

`public inline bool` `has_operator(const std::string & name) const`

`public inline` `SiteOperator` `get_site_operator(const std::string & name,const Parameters & p) const`

`public inline` `BondOperator` `get_bond_operator(const std::string & name,const Parameters & p) const`

`public inline` `SiteOperator` `get_site_operator(const std::string & name) const`

`public inline` `BondOperator` `get_bond_operator(const std::string & name) const`

`public inline` `GlobalOperator` `get_global_operator(const std::string & name) const`

`public template<>`
`inline void` `substitute_operators(OP & op,const Parameters & p) const`

`public inline std::set< std::string >` `quantum_numbers(int type)`

`typedef` `basis_descriptor_type`

`typedef` `site_basis_descriptor_type`

`typedef` `half_integer_type`

`typedef` `quantum_number_type`

class `alps::ModelLibrary`

Summary

Members	Descriptions
`public inline` `ModelLibrary()`
`public inline` `ModelLibrary(std::istream & in)`
`public inline` `ModelLibrary(const XMLTag & tag,std::istream & p)`
`public` `ModelLibrary(const Parameters & parms)`
`public inline void` `read_xml(std::istream & in)`
`public void` `read_xml(const XMLTag & tag,std::istream & p)`
`public void` `write_xml(alps::oxstream &) const`
`public bool` `has_basis(const std::string & name) const`
`public bool` `has_site_basis(const std::string & name) const`
`public bool` `has_hamiltonian(const std::string & name) const`
`public bool` `has_site_operator(const std::string & name) const`
`public bool` `has_bond_operator(const std::string & name) const`
`public bool` `has_global_operator(const std::string & name) const`
`public inline bool` `has_operator(const std::string & name) const`
`public const` `SiteBasisDescriptor< short > &` `get_site_basis(const std::string & name) const`
`public const` `BasisDescriptor< short > &` `get_basis(const std::string & name) const`
`public const` `HamiltonianDescriptor< short > &` `get_hamiltonian(const std::string & name) const`
`public` `HamiltonianDescriptor< short >` `get_hamiltonian(const std::string & name,Parameters const & parms,bool issymbolic) const`
`public inline` `HamiltonianDescriptor< short >` `get_hamiltonian(Parameters const & parms,bool issymbolic) const`
`public template<>` `inline` `HamiltonianDescriptor< short >` `get_hamiltonian(alps::graph_helper< G > const & g,Parameters const & parms,bool issymbolic) const`
`public template<>` `inline` `HamiltonianDescriptor< short >` `get_hamiltonian(alps::graph_helper< G > const & g,const std::string & name,Parameters const & parms,bool issymbolic) const`
`public inline const SiteOperatorMap &` `site_operators() const`
`public inline const BondOperatorMap &` `bond_operators() const`
`public inline const GlobalOperatorMap &` `global_operators() const`
`public` `SiteOperator` `get_site_operator(const std::string & name,Parameters const & p) const`
`public` `BondOperator` `get_bond_operator(const std::string & name,Parameters const & p) const`
`public` `GlobalOperator` `get_global_operator(const std::string & name,Parameters const & p) const`
`typedef` `OperatorDescriptorMap`
`typedef` `SiteOperatorMap`
`typedef` `BondOperatorMap`
`typedef` `GlobalOperatorMap`

Members

`public inline` `ModelLibrary()`

`public inline` `ModelLibrary(std::istream & in)`

`public inline` `ModelLibrary(const XMLTag & tag,std::istream & p)`

`public` `ModelLibrary(const Parameters & parms)`

`public inline void` `read_xml(std::istream & in)`

`public void` `read_xml(const XMLTag & tag,std::istream & p)`

`public void` `write_xml(alps::oxstream &) const`

`public bool` `has_basis(const std::string & name) const`

`public bool` `has_site_basis(const std::string & name) const`

`public bool` `has_hamiltonian(const std::string & name) const`

`public bool` `has_site_operator(const std::string & name) const`

`public bool` `has_bond_operator(const std::string & name) const`

`public bool` `has_global_operator(const std::string & name) const`

`public inline bool` `has_operator(const std::string & name) const`

`public const` `SiteBasisDescriptor< short > &` `get_site_basis(const std::string & name) const`

`public const` `BasisDescriptor< short > &` `get_basis(const std::string & name) const`

`public const` `HamiltonianDescriptor< short > &` `get_hamiltonian(const std::string & name) const`

`public` `HamiltonianDescriptor< short >` `get_hamiltonian(const std::string & name,Parameters const & parms,bool issymbolic) const`

`public inline` `HamiltonianDescriptor< short >` `get_hamiltonian(Parameters const & parms,bool issymbolic) const`

`public template<>`
`inline` `HamiltonianDescriptor< short >` `get_hamiltonian(alps::graph_helper< G > const & g,Parameters const & parms,bool issymbolic) const`

`public template<>`
`inline` `HamiltonianDescriptor< short >` `get_hamiltonian(alps::graph_helper< G > const & g,const std::string & name,Parameters const & parms,bool issymbolic) const`

`public inline const SiteOperatorMap &` `site_operators() const`

`public inline const BondOperatorMap &` `bond_operators() const`

`public inline const GlobalOperatorMap &` `global_operators() const`

`public` `SiteOperator` `get_site_operator(const std::string & name,Parameters const & p) const`

`public` `BondOperator` `get_bond_operator(const std::string & name,Parameters const & p) const`

`public` `GlobalOperator` `get_global_operator(const std::string & name,Parameters const & p) const`

`typedef` `OperatorDescriptorMap`

`typedef` `SiteOperatorMap`

`typedef` `BondOperatorMap`

`typedef` `GlobalOperatorMap`

class `alps::OperatorDescriptor`

class alps::OperatorDescriptor
  : private std::vector< std::pair< std::string, half_integer< I > > >

Summary

Members	Descriptions
`public inline` `OperatorDescriptor()`
`public inline` `OperatorDescriptor(const std::string & name,const std::string & elm)`
`public` `OperatorDescriptor(const XMLTag &,std::istream &)`
`public void` `write_xml(oxstream &) const`
`public template<>` `boost::tuple< STATE, expression::Expression< T >, bool >` `apply(STATE state,const` `SiteBasisDescriptor< I > & basis,const expression::ParameterEvaluator< T > & p,bool) const`
`public bool` `is_fermionic(const` `SiteBasisDescriptor< I > & basis) const`
`public inline const std::string &` `name() const`
`public inline const std::string &` `matrixelement() const`
`typedef` `const_iterator`
`typedef` `operator_map`

Members

`public inline` `OperatorDescriptor()`

`public inline` `OperatorDescriptor(const std::string & name,const std::string & elm)`

`public` `OperatorDescriptor(const XMLTag &,std::istream &)`

`public void` `write_xml(oxstream &) const`

`public template<>`
`boost::tuple< STATE, expression::Expression< T >, bool >` `apply(STATE state,const` `SiteBasisDescriptor & basis,const expression::ParameterEvaluator< T > & p,bool) const`

`public bool` `is_fermionic(const` `SiteBasisDescriptor & basis) const`

`public inline const std::string &` `name() const`

`public inline const std::string &` `matrixelement() const`

`typedef` `const_iterator`

`typedef` `operator_map`

class `alps::OperatorEvaluator`

class alps::OperatorEvaluator
  : public expression::ParameterEvaluator< std::complex< double > >

Summary

Members	Descriptions
`public inline` `OperatorEvaluator(const Parameters & p)`
`public inline super_type::Direction` `direction() const`
`public inline value_type` `evaluate(const std::string & name,bool isarg) const`
`public inline value_type` `evaluate_function(const std::string & name,const expression::Expression< T > & arg,bool isarg) const`
`public inline value_type` `evaluate_function(const std::string & name,const std::vector< expression::Expression< T > > & args,bool isarg) const`
`typedef` `super_type`
`typedef` `value_type`

Members

`public inline` `OperatorEvaluator(const Parameters & p)`

`public inline super_type::Direction` `direction() const`

`public inline value_type` `evaluate(const std::string & name,bool isarg) const`

`public inline value_type` `evaluate_function(const std::string & name,const expression::Expression< T > & arg,bool isarg) const`

`public inline value_type` `evaluate_function(const std::string & name,const std::vector< expression::Expression< T > > & args,bool isarg) const`

`typedef` `super_type`

`typedef` `value_type`

class `alps::OperatorSubstitution`

class alps::OperatorSubstitution
  : public expression::ParameterEvaluator< std::complex< double > >

Summary

Members	Descriptions
`public inline` `OperatorSubstitution(const` `ModelLibrary` `& lib,const Parameters & p,const std::vector< std::string > & s)`
`public expression::Expression< T >` `partial_evaluate(const std::string & name,bool) const`
`public bool` `can_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`
`public inline void` `substitute_arguments(const std::map< std::string, std::string > & p)`
`public inline void` `set_sites(const std::vector< std::string > & s)`
`typedef` `SiteOperatorMap`
`typedef` `BondOperatorMap`

Members

`public inline` `OperatorSubstitution(const` `ModelLibrary` `& lib,const Parameters & p,const std::vector< std::string > & s)`

`public expression::Expression< T >` `partial_evaluate(const std::string & name,bool) const`

`public bool` `can_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`

`public inline void` `substitute_arguments(const std::map< std::string, std::string > & p)`

`public inline void` `set_sites(const std::vector< std::string > & s)`

`typedef` `SiteOperatorMap`

`typedef` `BondOperatorMap`

class `alps::QuantumNumberDescriptor`

Summary

Members	Descriptions
`public` `QuantumNumberDescriptor(const std::string & n,value_type` `minVal,value_type` `maxVal,bool f)`
`public` `QuantumNumberDescriptor(const std::string & n,const std::string & min_str,const std::string & max_str,bool f)`
`public` `QuantumNumberDescriptor(const XMLTag &,std::istream &)`
`public inline bool` `valid(value_type` `x) const`
`public inline const std::string` `min_expression() const`
`public inline const std::string` `max_expression() const`
`public inline` `value_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline` `value_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const`
`public inline` `value_type` `global_max() const`
`public inline` `value_type` `global_min() const`
`public inline` `value_type` `global_increment() const`
`public inline range_type` `global_range() const`
`public inline I` `levels() const`
`public inline const std::string &` `name() const`
`public const` `QuantumNumberDescriptor&operator+=(const` `QuantumNumberDescriptor` `& rhs)`
`public void` `write_xml(alps::oxstream &) const`
`public inline bool` `fermionic() const`
`public bool` `set_parameters(const Parameters &)`
`public bool` `depends_on(const Parameters::key_type & s) const`
`public inline bool` `depends_on(const` `QuantumNumberDescriptor` `& qn) const`
`public inline void` `add_dependency(const` `QuantumNumberDescriptor` `& qn)`
`public inline void` `reset_limits()`
`public inline void` `update_limits()`
`typedef` `value_type`
`typedef` `range_type`

Members

`public` `QuantumNumberDescriptor(const std::string & n,value_type` `minVal,value_type` `maxVal,bool f)`

`public` `QuantumNumberDescriptor(const std::string & n,const std::string & min_str,const std::string & max_str,bool f)`

`public` `QuantumNumberDescriptor(const XMLTag &,std::istream &)`

`public inline bool` `valid(value_type` `x) const`

`public inline const std::string` `min_expression() const`

`public inline const std::string` `max_expression() const`

`public inline` `value_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline` `value_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const`

`public inline` `value_type` `global_max() const`

`public inline` `value_type` `global_min() const`

`public inline` `value_type` `global_increment() const`

`public inline range_type` `global_range() const`

`public inline I` `levels() const`

`public inline const std::string &` `name() const`

`public const` `QuantumNumberDescriptor&operator+=(const` `QuantumNumberDescriptor` `& rhs)`

`public void` `write_xml(alps::oxstream &) const`

`public inline bool` `fermionic() const`

`public bool` `set_parameters(const Parameters &)`

`public bool` `depends_on(const Parameters::key_type & s) const`

`public inline bool` `depends_on(const` `QuantumNumberDescriptor` `& qn) const`

`public inline void` `add_dependency(const` `QuantumNumberDescriptor` `& qn)`

`public inline void` `reset_limits()`

`public inline void` `update_limits()`

`typedef` `value_type`

`typedef` `range_type`

class `alps::single_qn_site_state`

Summary

Members	Descriptions
`public inline` `single_qn_site_state()`
`public inline` `single_qn_site_state(representation_type` `x)`
`public template<>` `inline` `single_qn_site_state(const std::vector<` `half_integer< J > > & x)`
`public inline` `operator representation_type() const`
`public inline` `representation_type` `state() const`
`public inline` `representation_type&state()`
`typedef` `representation_type`
`typedef` `quantumnumber_type`
`typedef` `size_type`

Members

`public inline` `single_qn_site_state()`

`public inline` `single_qn_site_state(representation_type` `x)`

`public template<>`
`inline` `single_qn_site_state(const std::vector<` `half_integer< J > > & x)`

`public inline` `operator representation_type() const`

`public inline` `representation_type` `state() const`

`public inline` `representation_type&state()`

`typedef` `representation_type`

`typedef` `quantumnumber_type`

`typedef` `size_type`

class `alps::site_basis`

class alps::site_basis
  : public std::vector< site_state< I > >

Summary

Members	Descriptions
`public` `site_basis(const` `SiteBasisDescriptor< I > & b)`
`public size_type` `index(const value_type & x) const`
`public inline const` `SiteBasisDescriptor< I > &` `basis() const`
`public bool` `check_sort() const`
`typedef` `state_type`
`typedef` `base_type`
`typedef` `const_iterator`
`typedef` `value_type`
`typedef` `size_type`

Members

`public` `site_basis(const` `SiteBasisDescriptor & b)`

`public size_type` `index(const value_type & x) const`

`public inline const` `SiteBasisDescriptor &` `basis() const`

`public bool` `check_sort() const`

`typedef` `state_type`

`typedef` `base_type`

`typedef` `const_iterator`

`typedef` `value_type`

`typedef` `size_type`

class `alps::site_basis_match`

class alps::site_basis_match
  : public alps::SiteBasisDescriptor< I >

Summary

Members	Descriptions
`public inline` `site_basis_match()`
`public inline` `site_basis_match(const` `super_type` `& site_basis,int type)`
`public inline` `site_basis_match(const std::string & name,int type)`
`public` `site_basis_match(const XMLTag &,std::istream &,const sitebasis_map_type & bases_)`
`public void` `write_xml(oxstream &) const`
`public inline bool` `match_type(int type) const`
`public void` `set_type(int type,Parameters const &)`
`public inline int` `type() const`
`typedef` `super_type`
`typedef` `const_iterator`
`typedef` `sitebasis_map_type`

Members

`public inline` `site_basis_match()`

`public inline` `site_basis_match(const` `super_type` `& site_basis,int type)`

`public inline` `site_basis_match(const std::string & name,int type)`

`public` `site_basis_match(const XMLTag &,std::istream &,const sitebasis_map_type & bases_)`

`public void` `write_xml(oxstream &) const`

`public inline bool` `match_type(int type) const`

`public void` `set_type(int type,Parameters const &)`

`public inline int` `type() const`

`typedef` `super_type`

`typedef` `const_iterator`

`typedef` `sitebasis_map_type`

class `alps::site_state`

class alps::site_state
  : public std::vector< half_integer< I > >

Summary

Members	Descriptions
`public inline` `site_state()`
`public inline` `site_state(const std::vector<` `half_integer< I > > & x)`
`typedef` `quantumnumber_type`
`typedef` `const_iterator`

Members

`public inline` `site_state()`

`public inline` `site_state(const std::vector<` `half_integer > & x)`

`typedef` `quantumnumber_type`

`typedef` `const_iterator`

class `alps::SiteBasisDescriptor`

class alps::SiteBasisDescriptor
  : public std::vector< QuantumNumberDescriptor< I > >

Summary

Members	Descriptions
`public inline` `SiteBasisDescriptor()`
`public inline` `SiteBasisDescriptor(const std::string & name,const Parameters & parms,const operator_map & ops)`
`public` `SiteBasisDescriptor(const XMLTag &,std::istream &)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `name() const`
`public bool` `valid(const std::vector<` `half_integer< I > > &) const`
`public inline std::size_t` `num_states() const`
`public bool` `set_parameters(const Parameters &,bool)`
`public inline const Parameters &` `get_parameters(bool all) const`
`public inline const operator_map &` `operators() const`
`public inline bool` `has_operator(const std::string & name) const`
`public template<>` `boost::tuple< STATE, expression::Expression< T >, bool >` `apply(const std::string & name,STATE state,const expression::ParameterEvaluator< T > & eval,bool) const`
`public bool` `is_fermionic(const std::string & name) const`
`typedef` `const_iterator`
`typedef` `iterator`
`typedef` `operator_map`
`typedef` `operator_iterator`

Members

`public inline` `SiteBasisDescriptor()`

`public inline` `SiteBasisDescriptor(const std::string & name,const Parameters & parms,const operator_map & ops)`

`public` `SiteBasisDescriptor(const XMLTag &,std::istream &)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `name() const`

`public bool` `valid(const std::vector<` `half_integer > &) const`

`public inline std::size_t` `num_states() const`

`public bool` `set_parameters(const Parameters &,bool)`

`public inline const Parameters &` `get_parameters(bool all) const`

`public inline const operator_map &` `operators() const`

`public inline bool` `has_operator(const std::string & name) const`

`public template<>`
`boost::tuple< STATE, expression::Expression< T >, bool >` `apply(const std::string & name,STATE state,const expression::ParameterEvaluator< T > & eval,bool) const`

`public bool` `is_fermionic(const std::string & name) const`

`typedef` `const_iterator`

`typedef` `iterator`

`typedef` `operator_map`

`typedef` `operator_iterator`

class `alps::SiteOperator`

Summary

Members	Descriptions
`public inline` `SiteOperator()`
`public inline` `SiteOperator(const std::string & t,const std::string & s)`
`public inline` `SiteOperator(SiteOperator` `const & op,std::string const & t,Parameters const & p)`
`public inline` `SiteOperator(const std::string & t)`
`public inline` `SiteOperator(const XMLTag & tag,std::istream & is)`
`public void` `read_xml(const XMLTag & tag,std::istream & is)`
`public void` `write_xml(oxstream &) const`
`public inline const std::string &` `site() const`
`public inline std::string &` `term()`
`public inline const std::string &` `term() const`
`public inline const std::string &` `name() const`
`public template<>` `multi_array< std::pair< T, bool >, 2 >` `matrix(const` `SiteBasisDescriptor< I > &,const Parameters & p) const`
`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`
`public std::set< std::string >` `operator_names() const`
`public template<>` `std::vector< boost::tuple< expression::Term< T >,` `SiteOperator> >templated_split(const Parameters &) const`
`public inline std::vector< boost::tuple< Term,` `SiteOperator> >split(const Parameters & p) const`
`public inline Parameters const &` `parms() const`

Members

`public inline` `SiteOperator()`

`public inline` `SiteOperator(const std::string & t,const std::string & s)`

`public inline` `SiteOperator(SiteOperator` `const & op,std::string const & t,Parameters const & p)`

`public inline` `SiteOperator(const std::string & t)`

`public inline` `SiteOperator(const XMLTag & tag,std::istream & is)`

`public void` `read_xml(const XMLTag & tag,std::istream & is)`

`public void` `write_xml(oxstream &) const`

`public inline const std::string &` `site() const`

`public inline std::string &` `term()`

`public inline const std::string &` `term() const`

`public inline const std::string &` `name() const`

`public template<>`
`multi_array< std::pair< T, bool >, 2 >` `matrix(const` `SiteBasisDescriptor &,const Parameters & p) const`

`public void` `substitute_operators(const` `ModelLibrary` `& m,const Parameters & p)`

`public std::set< std::string >` `operator_names() const`

`public template<>`
`std::vector< boost::tuple< expression::Term< T >,` `SiteOperator> >templated_split(const Parameters &) const`

`public inline std::vector< boost::tuple< Term,` `SiteOperator> >split(const Parameters & p) const`

`public inline Parameters const &` `parms() const`

class `alps::SiteOperatorEvaluator`

class alps::SiteOperatorEvaluator
  : public alps::OperatorEvaluator< T >

Summary

Members	Descriptions
`public inline` `SiteOperatorEvaluator(const state_type & s,const` `SiteBasisDescriptor< I > & b,const Parameters & p,const std::string sit)`
`public bool` `can_evaluate(const std::string &,bool) const`
`public bool` `can_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`
`public bool` `can_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`
`public expression::Expression< T >` `partial_evaluate(const std::string &,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`
`public inline const state_type &` `state() const`
`public inline bool` `fermionic() const`
`public inline const std::string &` `site() const`
`public inline bool` `has_operator(const std::string & n) const`
`typedef` `state_type`

Members

`public inline` `SiteOperatorEvaluator(const state_type & s,const` `SiteBasisDescriptor & b,const Parameters & p,const std::string sit)`

`public bool` `can_evaluate(const std::string &,bool) const`

`public bool` `can_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`

`public bool` `can_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`

`public expression::Expression< T >` `partial_evaluate(const std::string &,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const expression::Expression< T > &,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string &,const std::vector< expression::Expression< T > > &,bool) const`

`public inline const state_type &` `state() const`

`public inline bool` `fermionic() const`

`public inline const std::string &` `site() const`

`public inline bool` `has_operator(const std::string & n) const`

`typedef` `state_type`

class `alps::SiteOperatorSplitter`

class alps::SiteOperatorSplitter
  : public alps::OperatorEvaluator< std::complex< double > >

Summary

Members	Descriptions
`public inline` `SiteOperatorSplitter(const` `SiteBasisDescriptor< I > & b,const std::string & site,const Parameters & p)`
`public bool` `can_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`
`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`
`public inline const expression::Term< T > &` `site_operators() const`
`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`
`public inline expression::ParameterEvaluator< T >::Direction` `direction() const`

Members

`public inline` `SiteOperatorSplitter(const` `SiteBasisDescriptor & b,const std::string & site,const Parameters & p)`

`public bool` `can_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`

`public expression::Expression< T >` `partial_evaluate_function(const std::string & name,const expression::Expression< T > & argument,bool) const`

`public inline const expression::Term< T > &` `site_operators() const`

`public inline bool` `has_operator(const std::string & name,const expression::Expression< T > & arg) const`

`public inline expression::ParameterEvaluator< T >::Direction` `direction() const`

class `alps::SiteTermDescriptor`

class alps::SiteTermDescriptor
  : public alps::SiteOperator

Summary

Members	Descriptions
`public inline` `SiteTermDescriptor()`
`public inline` `SiteTermDescriptor(const std::string & t,const std::string & s)`
`public` `SiteTermDescriptor(const XMLTag &,std::istream &)`
`public inline` `SiteTermDescriptor(SiteTermDescriptor` `const & t,std::string const & term,Parameters const & p,unsigned int type)`
`public void` `write_xml(oxstream &) const`
`public inline const` `SiteOperator&site_operator() const`
`public inline bool` `match_type(int type) const`
`typedef` `super_type`

Members

`public inline` `SiteTermDescriptor()`

`public inline` `SiteTermDescriptor(const std::string & t,const std::string & s)`

`public` `SiteTermDescriptor(const XMLTag &,std::istream &)`

`public inline` `SiteTermDescriptor(SiteTermDescriptor` `const & t,std::string const & term,Parameters const & p,unsigned int type)`

`public void` `write_xml(oxstream &) const`

`public inline const` `SiteOperator&site_operator() const`

`public inline bool` `match_type(int type) const`

`typedef` `super_type`

struct `alps::nonzero_edge_weight`

Summary

Members	Descriptions
`public EdgeWeightMap` `m_weight`
`public inline` `nonzero_edge_weight()`
`public inline` `nonzero_edge_weight(EdgeWeightMap weight)`
`public template<>` `inline bool` `operator()(const Edge & e) const`

Members

`public EdgeWeightMap` `m_weight`

`public inline` `nonzero_edge_weight()`

`public inline` `nonzero_edge_weight(EdgeWeightMap weight)`

`public template<>`
`inline bool` `operator()(const Edge & e) const`

namespace `alps::detail`

Summary

Members	Descriptions
`public template<>` `Matrix` `initialized_matrix(Matrix const &,std::size_t const rows,std::size_t const cols)`
`public template<>` `alps::numeric::matrix< T, MemoryBlock >` `initialized_matrix(alps::numeric::matrix< T, MemoryBlock > const &,std::size_t const rows,std::size_t const cols)`
`public template<>` `BondSignVisitor< Graph, PropertyMap, BondPropertyMap >` `make_sign_visitor(const Graph &,PropertyMap & map,bool * check,BondPropertyMap bond_sign)`
`public template<>` `BondSiteSignVisitor< Graph, PropertyMap, BondPropertyMap, SitePropertyMap >` `make_sign_visitor(const Graph &,PropertyMap & map,bool * check,BondPropertyMap bond_sign,SitePropertyMap site_sign)`
`class` `alps::detail::BondMap`
`class` `alps::detail::BondSignVisitor`
`class` `alps::detail::BondSiteSignVisitor`
`class` `alps::detail::SiteMap`

Members

`public template<>`
`Matrix` `initialized_matrix(Matrix const &,std::size_t const rows,std::size_t const cols)`

`public template<>`
`alps::numeric::matrix< T, MemoryBlock >` `initialized_matrix(alps::numeric::matrix< T, MemoryBlock > const &,std::size_t const rows,std::size_t const cols)`

`public template<>`
`BondSignVisitor< Graph, PropertyMap, BondPropertyMap >` `make_sign_visitor(const Graph &,PropertyMap & map,bool * check,BondPropertyMap bond_sign)`

`public template<>`
`BondSiteSignVisitor< Graph, PropertyMap, BondPropertyMap, SitePropertyMap >` `make_sign_visitor(const Graph &,PropertyMap & map,bool * check,BondPropertyMap bond_sign,SitePropertyMap site_sign)`

class `alps::detail::BondMap`

Summary

Members	Descriptions
`public inline` `BondMap()`
`public inline` `BondMap(const map_type & map,const graph_type & graph)`
`public template<>` `inline int` `operator[](const E & e) const`
`typedef` `graph_type`
`typedef` `map_type`

Members

`public inline` `BondMap()`

`public inline` `BondMap(const map_type & map,const graph_type & graph)`

`public template<>`
`inline int` `operator[](const E & e) const`

`typedef` `graph_type`

`typedef` `map_type`

class `alps::detail::BondSignVisitor`

class alps::detail::BondSignVisitor
  : public boost::dfs_visitor<>

Summary

Members	Descriptions
`public inline` `BondSignVisitor()`
`public inline` `BondSignVisitor(PropertyMap & map,bool * check,BondPropertyMap bond_sign)`
`public inline void` `initialize_vertex(vertex_descriptor s,const Graph &)`
`public inline void` `start_vertex(vertex_descriptor s,const Graph &)`
`public inline void` `tree_edge(edge_descriptor e,const Graph & g)`
`public inline void` `back_edge(edge_descriptor e,const Graph & g)`
`typedef` `vertex_descriptor`
`typedef` `edge_descriptor`

Members

`public inline` `BondSignVisitor()`

`public inline` `BondSignVisitor(PropertyMap & map,bool * check,BondPropertyMap bond_sign)`

`public inline void` `initialize_vertex(vertex_descriptor s,const Graph &)`

`public inline void` `start_vertex(vertex_descriptor s,const Graph &)`

`public inline void` `tree_edge(edge_descriptor e,const Graph & g)`

`public inline void` `back_edge(edge_descriptor e,const Graph & g)`

`typedef` `vertex_descriptor`

`typedef` `edge_descriptor`

class `alps::detail::BondSiteSignVisitor`

class alps::detail::BondSiteSignVisitor
  : public boost::dfs_visitor<>

Summary

Members	Descriptions
`public inline` `BondSiteSignVisitor()`
`public inline` `BondSiteSignVisitor(PropertyMap & map,bool * check,BondPropertyMap bond_sign,SitePropertyMap site_sign)`
`public inline void` `initialize_vertex(vertex_descriptor s,const Graph &)`
`public inline void` `start_vertex(vertex_descriptor s,const Graph &)`
`public inline void` `tree_edge(edge_descriptor e,const Graph & g)`
`public inline void` `back_edge(edge_descriptor e,const Graph & g)`
`typedef` `vertex_descriptor`
`typedef` `edge_descriptor`

Members

`public inline` `BondSiteSignVisitor()`

`public inline` `BondSiteSignVisitor(PropertyMap & map,bool * check,BondPropertyMap bond_sign,SitePropertyMap site_sign)`

`public inline void` `initialize_vertex(vertex_descriptor s,const Graph &)`

`public inline void` `start_vertex(vertex_descriptor s,const Graph &)`

`public inline void` `tree_edge(edge_descriptor e,const Graph & g)`

`public inline void` `back_edge(edge_descriptor e,const Graph & g)`

`typedef` `vertex_descriptor`

`typedef` `edge_descriptor`

class `alps::detail::SiteMap`

Summary

Members	Descriptions
`public inline` `SiteMap()`
`public inline` `SiteMap(const map_type & map,const graph_type & graph)`
`public template<>` `inline int` `operator[](const V & v) const`
`typedef` `graph_type`
`typedef` `map_type`

Members

`public inline` `SiteMap()`

`public inline` `SiteMap(const map_type & map,const graph_type & graph)`

`public template<>`
`inline int` `operator[](const V & v) const`

`typedef` `graph_type`

`typedef` `map_type`

namespace `alps::numeric`

Summary

Members	Descriptions
`class` `alps::numeric::matrix`

class `alps::numeric::matrix`

Summary

Members	Descriptions

Members

class `alps::integer_state::reference`

Summary

Members	Descriptions
`public inline` `reference(I & s,int i)`
`public inline` `operator int() const`
`public template<>` `inline` `reference&operator=(T x)`

Members

`public inline` `reference(I & s,int i)`

`public inline` `operator int() const`

`public template<>`
`inline` `reference&operator=(T x)`

class `alps::integer_state< I, 1 >::reference`

Summary

Members	Descriptions
`public inline` `reference(I & s,int i)`
`public inline` `operator int() const`
`public template<>` `inline` `reference&operator=(T x)`

Members

`public inline` `reference(I & s,int i)`

`public inline` `operator int() const`

`public template<>`
`inline` `reference&operator=(T x)`

struct `alps::half_integer::to_distinguish`

Summary

Members	Descriptions

Members

Generated by Moxygen

Introduction

Reference

Summary

namespace alps

Summary

Members

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::site_basis_match< I > & q)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::BasisDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::site_basis_match< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::BasisDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::basis_states< I, S, SS > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::lookup_basis_states< I, J, S, SS > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::bloch_basis_states< I, S, SS > & q)

public template<>multi_array< std::pair< T, bool >, 4 > get_fermionic_matrix(T,const BondOperator& m,constSiteBasisDescriptor< I > & basis1,const SiteBasisDescriptor< I > & basis2,const Parameters & p)

public template<>multi_array< T, 4 > get_matrix(T,const BondOperator& m,constSiteBasisDescriptor< I > & basis1,const SiteBasisDescriptor< I > & basis2,const Parameters & p)

public inline alps::oxstream & operator<<(alps::oxstream & out,const alps::BondOperator & q)

public inline std::ostream & operator<<(std::ostream & out,const alps::BondOperator & q)

public inline alps::oxstream & operator<<(alps::oxstream & out,const alps::BondTermDescriptor & q)

public inline std::ostream & operator<<(std::ostream & out,const alps::BondTermDescriptor & q)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::DefaultTermDescriptor< TERM > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::DefaultTermDescriptor< TERM > & q)

public inline alps::oxstream & operator<<(alps::oxstream & out,const alps::GlobalOperator & q)

public inline std::ostream & operator<<(std::ostream & out,const alps::GlobalOperator & q)

public template<>inline double to_double(const half_integer< I > & x)

public template<>inline I to_integer(const half_integer< I > & x)

public template<>inline bool is_odd(T x)

public template<>inline bool is_odd(const half_integer< I > & x)

public template<>inline half_integer< I > abs(const half_integer< I > & x)

public template<>inline bool operator==(double x,const alps::half_integer< I > & y)

public template<>inline bool operator!=(double x,const alps::half_integer< I > & y)

public template<>inline bool operator<(double x,const alps::half_integer< I > & y)

public template<>inline bool operator>(double x,const alps::half_integer< I > & y)

public template<>inline bool operator<=(double x,const alps::half_integer< I > & y)

public template<>inline bool operator>=(double x,const alps::half_integer< I > & y)

public template<>inline alps::half_integer< I > operator+(double x,const alps::half_integer< I > & y)

public template<>inline alps::half_integer< I > operator-(double x,const alps::half_integer< I > & y)

public template<>inline std::ostream & operator<<(std::ostream & os,const alps::half_integer< I > & x)

public template<>inline std::istream & operator>>(std::istream & is,alps::half_integer< I > & x)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::HamiltonianDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::HamiltonianDescriptor< I > & q)

public template<>bool operator==(integer_state< I, N > x,integer_state< I, N > y)

public template<>bool operator<(integer_state< I, N > x,integer_state< I, N > y)

public inline alps::oxstream & operator<<(alps::oxstream & os,const alps::ModelLibrary & l)

public inline std::ostream & operator<<(std::ostream & os,const alps::ModelLibrary & l)

public inline std::istream & operator>>(std::istream & is,alps::ModelLibrary & l)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::OperatorDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::OperatorDescriptor< I > & q)

public template<>inline bool operator<(const QuantumNumberDescriptor< I > & q1,const QuantumNumberDescriptor< I > & q2)

public template<>QuantumNumberDescriptor< I > operator+(const QuantumNumberDescriptor< I > & x,const QuantumNumberDescriptor< I > & y)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::QuantumNumberDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::QuantumNumberDescriptor< I > & q)

public template<>bool is_frustrated(const G & graph,B bond_map)

public template<>bool is_frustrated(const G & graph,B bond_map,S site_map)

public template<>bool has_sign_problem(const HamiltonianDescriptor< I > & ham,const graph_helper< G > & lattice,const Parameters & p)

public template<>inline alps::oxstream & operator<<(alps::oxstream & out,const alps::SiteBasisDescriptor< I > & q)

public template<>inline std::ostream & operator<<(std::ostream & out,const alps::SiteBasisDescriptor< I > & q)

public template<>bool is_fermionic(const site_basis< I, STATE > & b,int s)

public template<>std::ostream & operator<<(std::ostream & out,const alps::site_basis< I, STATE > & s)

public template<>inline multi_array< std::pair< T, bool >, 2 > get_fermionic_matrix(T,const SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p)

public template<>multi_array< T, 2 > get_matrix(T,const SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p,bool ignore_fermion)

public inline alps::oxstream & operator<<(alps::oxstream & out,const alps::SiteOperator & q)

public inline std::ostream & operator<<(std::ostream & out,const alps::SiteOperator & q)

public template<>bool operator<(const single_qn_site_state< I > & x,const single_qn_site_state< I > & y)

public template<>bool operator>(const single_qn_site_state< I > & x,const single_qn_site_state< I > & y)

public template<>bool operator==(const single_qn_site_state< I > & x,const single_qn_site_state< I > & y)

public template<>bool operator<=(const single_qn_site_state< I > & x,const single_qn_site_state< I > & y)

public template<>bool operator>=(const single_qn_site_state< I > & x,const single_qn_site_state< I > & y)

public template<>half_integer< I > get_quantumnumber(const site_state< I > & s,typename site_state< I >::size_type i)

public template<>half_integer< I > get_quantumnumber(const single_qn_site_state< I > & s,std::size_t i)

public template<>half_integer< I > & get_quantumnumber(site_state< I > & s,typename site_state< I >::size_type i)

public template<>half_integer< I > & get_quantumnumber(single_qn_site_state< I > & s,std::size_t i)

public template<>std::size_t get_quantumnumber_index(const std::string & n,const SiteBasisDescriptor< I > & b)

public template<>S::quantumnumber_type get_quantumnumber(const S & s,const std::string & n,const SiteBasisDescriptor< I > & b)

public template<>bool is_fermionic(const SiteBasisDescriptor< I > & b,const S & s)

public template<>std::ostream & operator<<(std::ostream & out,const alps::site_state< I > & s)

public template<>std::ostream & operator<<(std::ostream & out,const alps::single_qn_site_state< I > & s)

public inline alps::oxstream & operator<<(alps::oxstream & out,const alps::SiteTermDescriptor & q)

public inline std::ostream & operator<<(std::ostream & out,const alps::SiteTermDescriptor & q)

public inline std::string substitute(std::string const & text,unsigned int type)

public inline Parameters substitute(Parameters const & parms,unsigned int type)

class alps::basis_states

namespace `alps`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::site_basis_match< I > & q)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BasisDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis_match< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BasisDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::basis_states< I, S, SS > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::lookup_basis_states< I, J, S, SS > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::bloch_basis_states< I, S, SS > & q)`

`public template<>`
`multi_array< std::pair< T, bool >, 4 >` `get_fermionic_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor< I > & basis1,const` `SiteBasisDescriptor< I > & basis2,const Parameters & p)`

`public template<>`
`multi_array< T, 4 >` `get_matrix(T,const` `BondOperator& m,constSiteBasisDescriptor< I > & basis1,const` `SiteBasisDescriptor< I > & basis2,const Parameters & p)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondOperator` `& q)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::BondTermDescriptor` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::BondTermDescriptor` `& q)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::DefaultTermDescriptor< TERM > & q)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::GlobalOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::GlobalOperator` `& q)`

`public template<>`
`inline double` `to_double(const` `half_integer< I > & x)`

`public template<>`
`inline I` `to_integer(const` `half_integer< I > & x)`

`public template<>`
`inline bool` `is_odd(T x)`

`public template<>`
`inline bool` `is_odd(const` `half_integer< I > & x)`

`public template<>`
`inline` `half_integer< I >` `abs(const` `half_integer< I > & x)`

`public template<>`
`inline bool` `operator==(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline bool` `operator!=(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline bool` `operator<(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline bool` `operator>(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline bool` `operator<=(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline bool` `operator>=(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline` `alps::half_integer< I >` `operator+(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline` `alps::half_integer< I >` `operator-(double x,const` `alps::half_integer< I > & y)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & os,const` `alps::half_integer< I > & x)`

`public template<>`
`inline std::istream &` `operator>>(std::istream & is,alps::half_integer< I > & x)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::HamiltonianDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::HamiltonianDescriptor< I > & q)`

`public template<>`
`bool` `operator==(integer_state< I, N > x,integer_state< I, N > y)`

`public template<>`
`bool` `operator<(integer_state< I, N > x,integer_state< I, N > y)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & os,const` `alps::ModelLibrary` `& l)`

`public inline std::ostream &` `operator<<(std::ostream & os,const` `alps::ModelLibrary` `& l)`

`public inline std::istream &` `operator>>(std::istream & is,alps::ModelLibrary` `& l)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::OperatorDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::OperatorDescriptor< I > & q)`

`public template<>`
`inline bool` `operator<(const` `QuantumNumberDescriptor< I > & q1,const` `QuantumNumberDescriptor< I > & q2)`

`public template<>`
`QuantumNumberDescriptor< I >` `operator+(const` `QuantumNumberDescriptor< I > & x,const` `QuantumNumberDescriptor< I > & y)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::QuantumNumberDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::QuantumNumberDescriptor< I > & q)`

`public template<>`
`bool` `is_frustrated(const G & graph,B bond_map)`

`public template<>`
`bool` `is_frustrated(const G & graph,B bond_map,S site_map)`

`public template<>`
`bool` `has_sign_problem(const` `HamiltonianDescriptor< I > & ham,const graph_helper< G > & lattice,const Parameters & p)`

`public template<>`
`inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteBasisDescriptor< I > & q)`

`public template<>`
`inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteBasisDescriptor< I > & q)`

`public template<>`
`bool` `is_fermionic(const` `site_basis< I, STATE > & b,int s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::site_basis< I, STATE > & s)`

`public template<>`
`inline multi_array< std::pair< T, bool >, 2 >` `get_fermionic_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p)`

`public template<>`
`multi_array< T, 2 >` `get_matrix(T,const` `SiteOperator& m,constSiteBasisDescriptor< I > & basis1,const Parameters & p,bool ignore_fermion)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteOperator` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteOperator` `& q)`

`public template<>`
`bool` `operator<(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`

`public template<>`
`bool` `operator>(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`

`public template<>`
`bool` `operator==(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`

`public template<>`
`bool` `operator<=(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`

`public template<>`
`bool` `operator>=(const` `single_qn_site_state< I > & x,const` `single_qn_site_state< I > & y)`

`public template<>`
`half_integer< I >` `get_quantumnumber(const` `site_state< I > & s,typename` `site_state< I >::size_type i)`

`public template<>`
`half_integer< I >` `get_quantumnumber(const` `single_qn_site_state< I > & s,std::size_t i)`

`public template<>`
`half_integer< I > &` `get_quantumnumber(site_state< I > & s,typename` `site_state< I >::size_type i)`

`public template<>`
`half_integer< I > &` `get_quantumnumber(single_qn_site_state< I > & s,std::size_t i)`

`public template<>`
`std::size_t` `get_quantumnumber_index(const std::string & n,const` `SiteBasisDescriptor< I > & b)`

`public template<>`
`S::quantumnumber_type` `get_quantumnumber(const S & s,const std::string & n,const` `SiteBasisDescriptor< I > & b)`

`public template<>`
`bool` `is_fermionic(const` `SiteBasisDescriptor< I > & b,const S & s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::site_state< I > & s)`

`public template<>`
`std::ostream &` `operator<<(std::ostream & out,const` `alps::single_qn_site_state< I > & s)`

`public inline alps::oxstream &` `operator<<(alps::oxstream & out,const` `alps::SiteTermDescriptor` `& q)`

`public inline std::ostream &` `operator<<(std::ostream & out,const` `alps::SiteTermDescriptor` `& q)`

`public inline std::string` `substitute(std::string const & text,unsigned int type)`

`public inline Parameters` `substitute(Parameters const & parms,unsigned int type)`

class `alps::basis_states`

`public inline` `basis_states()`

`public template<>`
`inline` `basis_states(const` `basis_states_descriptor< I, SS > & b,const std::vector< std::pair< std::string,` `half_integer< J > > > & c)`

`public inline` `basis_states(const` `basis_states_descriptor< I, SS > & b)`

`public inline std::size_t` `index(const value_type & x) const`