ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Reference

Header <alps/lattice/bond_compare.h>
Header <alps/lattice/boundary.h>
Header <alps/lattice/cell_traits.h>
Header <alps/lattice/coordinate_traits.h>
Header <alps/lattice/coordinatelattice.h>
Header <alps/lattice/dimensional_traits.h>
Header <alps/lattice/disorder.h>
Header <alps/lattice/graph.h>
Header <alps/lattice/graph_helper.h>
Header <alps/lattice/graph_traits.h>
Header <alps/lattice/graphproperties.h>
Header <alps/lattice/hypercubic.h>
Header <alps/lattice/lattice.h>
Header <alps/lattice/latticedescriptor.h>
Header <alps/lattice/latticegraph.h>
Header <alps/lattice/latticegraphdescriptor.h>
Header <alps/lattice/latticelibrary.h>
Header <alps/lattice/parity.h>
Header <alps/lattice/point_traits.h>
Header <alps/lattice/propertymap.h>
Header <alps/lattice/simplecell.h>
Header <alps/lattice/simplelattice.h>
Header <alps/lattice/unitcell.h>
namespace alps {
  template<typename G> struct bond_descriptor_compare;
  template<typename G> struct bond_descriptor_compare_undirected;
}
namespace alps {
  struct boundary_crossing;
}
namespace alps {
  template<typename C> struct cell_traits;
}
namespace alps {
  template<typename C> struct coordinate_traits;

  template<typename C> struct coordinate_traits<const C>;
  template<typename T> struct coordinate_traits<std::valarray< T >>;
  template<typename C> 
    std::pair< typename coordinate_traits< C >::iterator, typename coordinate_traits< C >::iterator > 
    coordinates(C & c);
  template<typename T> 
    std::pair< T *, T * > coordinates(std::valarray< T > & c);
  template<typename T> 
    std::pair< const T *, const T * > 
    coordinates(const std::valarray< T > & c);
  template<typename C> 
    std::string coordinate_to_string(const C & c, int precision = 0);
}
namespace alps {
  template<typename BASE = simple_lattice<>, 
           typename Vector = std::vector<double> > 
    class coordinate_lattice;

  template<typename B, typename V> 
    struct lattice_traits<coordinate_lattice< B, V >>;
}
namespace alps {
  template<typename Dimensional> struct dimensional_traits;
  template<typename T, typename A> 
    dimensional_traits< std::vector< T, A > >::dimension_type 
    dimension(const std::vector< T, A > & d);
}
namespace alps {
  class InhomogeneityDescriptor;
  class DepletionDescriptor;
  class Depletion;
  template<typename G, typename MAP> void disorder_vertices(G & g, MAP & type);
  template<typename G, typename MAP> void disorder_edges(G & g, MAP & type);
  template<typename G, typename MAP> void disorder_bonds(G & g, MAP & type);
  template<typename G, typename MAP> void disorder_sites(G & g, MAP & t);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::InhomogeneityDescriptor & l);
  std::ostream & 
  operator<<(std::ostream & out, const alps::InhomogeneityDescriptor & l);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::DepletionDescriptor & l);
  std::ostream & 
  operator<<(std::ostream & out, const alps::DepletionDescriptor & l);
}
namespace alps {
  template<typename GRAPH> 
    void write_graph_xml(oxstream & out, const GRAPH & g, 
                         const std::string & n = "");
  template<typename GRAPH> 
    std::string read_graph_xml(std::istream & in, GRAPH & g);
  template<typename GRAPH> 
    std::string read_graph_xml(const XMLTag & intag, std::istream & p, 
                               GRAPH & g);
  template<typename PROPERTY, typename SRC, typename SRCREF, typename DST, 
           typename DSTREF> 
    void copy_property(PROPERTY, const SRC & s, const SRCREF & sr, DST & d, 
                       DSTREF & dr);
  template<typename PROPERTY, typename SRC, typename DST> 
    void copy_property(PROPERTY, const SRC & s, DST & d);
  template<typename SRC, typename DST> 
    void copy_graph(const SRC & src, DST & dst);
  template<typename G> int constant_degree(const G & g);
  template<typename G> std::size_t maximum_edge_type(const G & g);
  template<typename G> std::size_t maximum_vertex_type(const G & g);
}namespace boost {
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    std::ostream & 
    operator<<(std::ostream & os, 
               const boost::adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::oxstream & 
    operator<<(alps::oxstream & oxs, 
               const boost::adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
}
namespace alps {
  template<typename G = coordinate_graph_type> class graph_helper;
  template<typename G> 
    void throw_if_xyz_defined(const Parameters & p, const G & graph);
  template<typename G> 
    Parameters coordinate_as_parameter(const G & graph, 
                                       const typename boost::graph_traits< G >::edge_descriptor & edge);
  template<typename G> 
    Parameters coordinate_as_parameter(const G & graph, 
                                       const typename boost::graph_traits< G >::vertex_descriptor & vertex);
  template<typename G> 
    std::string site_label(G const & g, 
                           typename graph_traits< G >::site_descriptor const & v, 
                           int precision = 0);
  template<typename G> 
    std::vector< std::string > site_labels(G const & g, int precision = 0);
  template<typename G> 
    std::string bond_label(G const & g, 
                           typename graph_traits< G >::bond_descriptor const & e, 
                           int precision = 0);
  template<typename G> 
    std::vector< std::string > bond_labels(G const & g, int precision = 0);
}
namespace alps {
  template<typename G> struct graph_traits;
}namespace boost {
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::sites_size_type 
    num_sites(const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::bonds_size_type 
    num_bonds(const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    std::pair< typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_iterator, typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_iterator > 
    sites(const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor 
    site(typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::sites_size_type i, 
         const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    std::pair< typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::bond_iterator, typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::bond_iterator > 
    bonds(const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::bond_descriptor 
    bond(typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::bonds_size_type i, 
         const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::degree_size_type 
    num_neighbors(const typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor & v, 
                  const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    std::pair< typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::neighbor_bond_iterator, typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::neighbor_bond_iterator > 
    neighbor_bonds(const typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor & v, 
                   const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    std::pair< typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::neighbor_iterator, typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::neighbor_iterator > 
    neighbors(const typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor & v, 
              const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
  template<typename T0, typename T1, typename T2, typename T3, typename T4, 
           typename T5, typename T6> 
    alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor 
    neighbor(const typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::site_descriptor & v, 
             typename alps::graph_traits< adjacency_list< T0, T1, T2, T3, T4, T5, T6 > >::degree_size_type i, 
             const adjacency_list< T0, T1, T2, T3, T4, T5, T6 > & g);
}
namespace alps {
  struct vertex_type_t;
  struct coordinate_t;
  struct parity_t;
  struct edge_type_t;
  struct source_offset_t;
  struct target_offset_t;
  struct boundary_crossing_t;
  struct edge_vector_t;
  struct edge_vector_relative_t;
  struct graph_name_t;
  struct dimension_t;

  typedef vertex_type_t site_type_t;
  typedef edge_type_t bond_type_t;
  typedef edge_vector_t bond_vector_t;
  typedef edge_vector_relative_t bond_vector_relative_t;
  typedef vertex_index_t site_index_t;
  typedef edge_index_t bond_index_t;
  typedef std::vector< double > coordinate_type;
  typedef std::vector< int > offset_type;
  typedef std::vector< int > distance_type;
  typedef unsigned int type_type;
  typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, boost::property< coordinate_t, coordinate_type, boost::property< parity_t, int8_t, boost::property< vertex_type_t, type_type > > >, boost::property< edge_type_t, type_type, boost::property< boost::edge_index_t, unsigned int, boost::property< boundary_crossing_t, boundary_crossing, boost::property< bond_vector_t, coordinate_type, boost::property< bond_vector_relative_t, coordinate_type > > > > >, boost::property< dimension_t, std::size_t, boost::property< graph_name_t, std::string > >, boost::vecS > coordinate_graph_type;
  typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, boost::no_property, boost::property< boost::edge_index_t, unsigned int >, boost::property< dimension_t, std::size_t, boost::property< graph_name_t, std::string > >, boost::vecS > minimal_graph_type;
}

M_PI
namespace alps {
  template<typename BASE, typename EX> class hypercubic_lattice;

  template<typename BASE, typename EX> 
    struct lattice_traits<hypercubic_lattice< BASE, EX >>;
  template<typename BASE, typename EX> 
    std::size_t dimension(const hypercubic_lattice< BASE, EX > & l);
}
namespace alps {
  template<typename L> struct lattice_traits;
  template<typename Lattice> 
    const lattice_traits< Lattice >::unit_cell_type & 
    unit_cell(const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::cell_descriptor 
    cell(const typename lattice_traits< Lattice >::offset_type & o, 
         const Lattice & l);
  template<typename Lattice> 
    const lattice_traits< Lattice >::offset_type & 
    offset(const typename lattice_traits< Lattice >::cell_descriptor & c, 
           const Lattice &);
  template<typename Lattice> 
    lattice_traits< Lattice >::size_type volume(const Lattice & l);
  template<typename Lattice> 
    bool on_lattice(const typename lattice_traits< Lattice >::offset_type & o, 
                    const Lattice & l);
  template<typename Lattice> 
    std::pair< typename lattice_traits< Lattice >::cell_iterator, typename lattice_traits< Lattice >::cell_iterator > 
    cells(const Lattice & l);
  template<typename Lattice> 
    std::pair< bool, typename lattice_traits< Lattice >::boundary_crossing_type > 
    shift(typename lattice_traits< Lattice >::offset_type & o, 
          const typename lattice_traits< Lattice >::offset_type & s, 
          const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::size_type 
    index(const typename lattice_traits< Lattice >::cell_descriptor & c, 
          const Lattice & l);
  template<typename Lattice> 
    std::pair< typename lattice_traits< Lattice >::basis_vector_iterator, typename lattice_traits< Lattice >::basis_vector_iterator > 
    basis_vectors(const Lattice & l);
  template<typename Lattice> 
    std::pair< typename lattice_traits< Lattice >::basis_vector_iterator, typename lattice_traits< Lattice >::basis_vector_iterator > 
    reciprocal_basis_vectors(const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::vector_type 
    coordinate(const typename lattice_traits< Lattice >::cell_descriptor & c, 
               const typename lattice_traits< Lattice >::vector_type & p, 
               const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::vector_type 
    origin(const typename lattice_traits< Lattice >::cell_descriptor & c, 
           const Lattice & l);
  void ALPS_DECL prevent_optimization();
  template<typename Lattice> 
    std::pair< typename lattice_traits< Lattice >::momentum_iterator, typename lattice_traits< Lattice >::momentum_iterator > 
    momenta(const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::vector_type 
    momentum(const typename lattice_traits< Lattice >::vector_type & m, 
             const Lattice & l);
  template<typename Lattice> 
    lattice_traits< Lattice >::extent_type extent(const Lattice & l);
  template<typename Lattice> 
    element_type< typename lattice_traits< Lattice >::extent_type >::type 
    extent(const Lattice & l, unsigned int d);
}
namespace alps {
  class LatticeDescriptor;
  class FiniteLatticeDescriptor;

  typedef std::map< std::string, LatticeDescriptor > LatticeMap;
  typedef std::map< std::string, FiniteLatticeDescriptor > FiniteLatticeMap;
  dimensional_traits< LatticeDescriptor >::dimension_type 
  dimension(const LatticeDescriptor & c);
  dimensional_traits< FiniteLatticeDescriptor >::dimension_type 
  dimension(const FiniteLatticeDescriptor & c);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::LatticeDescriptor & l);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::FiniteLatticeDescriptor & l);
  std::ostream & 
  operator<<(std::ostream & out, const alps::LatticeDescriptor & l);
  std::ostream & 
  operator<<(std::ostream & out, const alps::FiniteLatticeDescriptor & l);
}
namespace alps {
  template<typename LATTICE, typename GRAPH> class lattice_graph;

  template<typename L, typename G> 
    struct lattice_traits<lattice_graph< L, G >>;
  template<typename L, typename G> struct graph_traits<lattice_graph< L, G >>;
  template<typename LATTICE, typename GRAPH> 
    void make_graph_from_lattice(GRAPH & g, const LATTICE & l, 
                                 DepletionDescriptor depl_desc = DepletionDescriptor());
  template<typename L, typename G> 
    std::size_t dimension(const lattice_graph< L, G > & l);
  namespace graph {
    template<typename L, typename G> 
      lattice_graph< L, G >::graph_type & graph(lattice_graph< L, G > & l);
    template<typename L, typename G> 
      const lattice_graph< L, G >::graph_type & 
      graph(const lattice_graph< L, G > & l);
  }
}
namespace alps {
  class LatticeGraphDescriptor;

  template<> struct lattice_traits<LatticeGraphDescriptor>;

  typedef lattice_graph< LatticeGraphDescriptor, coordinate_graph_type > HypercubicLatticeGraphDescriptor;
  typedef lattice_graph< hypercubic_lattice< coordinate_lattice< simple_lattice< GraphUnitCell > > >, coordinate_graph_type > HypercubicLatticeGraph;
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::LatticeGraphDescriptor & l);
  std::ostream & 
  operator<<(std::ostream & out, const alps::LatticeGraphDescriptor & l);
}
namespace alps {
  class LatticeLibrary;
  alps::oxstream & 
  operator<<(alps::oxstream & xml, const alps::LatticeLibrary & l);
  std::ostream & operator<<(std::ostream & os, const alps::LatticeLibrary & l);
  std::istream & operator>>(std::istream & is, alps::LatticeLibrary & l);
}
namespace alps {
  template<typename Graph> struct parity_traits<parity_t, Graph>;
  template<typename Graph, typename Parity> 
    bool set_parity(Graph & g, alps::Parameters const & p, Parity);
  template<typename Graph> 
    bool set_parity(Graph & g, alps::Parameters const & p);
  template<typename Graph> bool set_parity(Graph & g);
}
namespace alps {
  template<typename P> struct point_traits;
}
namespace alps {
  template<typename V, typename K = boost::any> class singleton_property_map;

  template<typename Property, typename Graph, typename Default = int> 
    struct has_property;

  template<typename s1, typename s2, typename s3, typename VP, typename EP, 
           typename GP, typename s4, typename P, typename D> 
    struct has_property<P, boost::adjacency_list< s1, s2, s3, VP, EP, GP, s4 >, D>;
  template<typename s1, typename s2, typename s3, typename VP, typename EP, 
           typename GP, typename s4, typename P, typename D> 
    struct has_property<P, const boost::adjacency_list< s1, s2, s3, VP, EP, GP, s4 >, D>;

  template<typename P, typename G, typename Default> struct property_map;

  template<typename P, typename G, typename Default> 
    struct property_map<P, const G, Default>;

  template<typename SRC, typename DST, typename PROPERTY, bool has_property> 
    struct copy_property_helper;

  template<typename SRC, typename DST, typename PROPERTY> 
    struct copy_property_helper<SRC, DST, PROPERTY, true>;
  template<typename P, typename G, typename V> 
    property_map< P, G, V >::type get_or_default(P p, G & g, const V & v);
}namespace boost {
  template<typename V, typename K> 
    V get(const alps::singleton_property_map< V, K > & m, const K &);
  template<typename V, typename K> 
    void put(alps::singleton_property_map< V, K > & m, const K & k, 
             const V & v);
}
namespace alps {
  template<typename UnitCell = EmptyUnitCell, 
           typename Offset = typename std::vector<int> > 
    class simple_cell;
  template<typename UnitCell, typename Offset> 
    simple_cell< UnitCell, Offset >::dimension_type 
    dimension(const simple_cell< UnitCell, Offset > & c);
}
namespace alps {
  template<typename UnitCell = EmptyUnitCell, 
           typename Cell = simple_cell<UnitCell> > 
    class simple_lattice;

  template<typename U, typename C> 
    struct lattice_traits<simple_lattice< U, C >>;
  template<typename U, typename C> 
    dimensional_traits< simple_lattice< U, C > >::dimension_type 
    dimension(const simple_lattice< U, C > & l);
  template<typename UnitCell, typename Cell> 
    simple_lattice< UnitCell, Cell >::unit_cell_type & 
    unit_cell(simple_lattice< UnitCell, Cell > & l);
  template<typename UnitCell, typename Cell> 
    const simple_lattice< UnitCell, Cell >::unit_cell_type & 
    unit_cell(const simple_lattice< UnitCell, Cell > & l);
}
namespace alps {
  class EmptyUnitCell;
  class GraphUnitCell;

  typedef std::map< std::string, GraphUnitCell > UnitCellMap;
  dimensional_traits< EmptyUnitCell >::dimension_type 
  dimension(const EmptyUnitCell & c);
  dimensional_traits< GraphUnitCell >::dimension_type 
  dimension(const GraphUnitCell & c);
  alps::oxstream & 
  operator<<(alps::oxstream & out, const alps::GraphUnitCell & u);
  std::ostream & operator<<(std::ostream & out, const alps::GraphUnitCell & u);
  namespace graph {
    GraphUnitCell::graph_type & graph(GraphUnitCell & c);
    const GraphUnitCell::graph_type & graph(const GraphUnitCell & c);
  }
}
Copyright 1994, 2002-2005 Matthias Troyer, Synge Todo

PrevUpHomeNext