Logo Search packages:      
Sourcecode: boost version File versions

boost Namespace Reference


Detailed Description

Boost namespace


Classes

struct  AdaptableBinaryFunctionConcept
struct  AdaptableBinaryPredicateConcept
struct  AdaptableGeneratorConcept
struct  AdaptablePredicateConcept
struct  AdaptableUnaryFunctionConcept
struct  addable1
struct  additive1
struct  additive2
struct  adj_list_all_vertex_pa
struct  adj_list_any_vertex_pa
struct  adj_list_dir_traversal_tag
struct  adj_list_edge_all_properties_map
struct  adj_list_edge_property_map
struct  adj_list_helper
class  adj_list_impl
struct  adj_list_tag
struct  adj_list_vertex_all_properties_map
struct  adj_list_vertex_property_map
struct  adj_list_vertex_property_selector
class  adj_matrix_edge_property_map
struct  adj_matrix_edge_property_selector
struct  adj_matrix_traversal_tag
struct  adj_matrix_vertex_id_map
class  adj_matrix_vertex_property_map
struct  adjacency_graph_archetype
struct  adjacency_graph_tag
struct  adjacency_iterator
class  adjacency_iterator_generator
class  adjacency_list
struct  adjacency_list_traits
class  adjacency_matrix
struct  adjacency_matrix_class_tag
struct  adjacency_matrix_tag
class  adjacency_matrix_traits
struct  AdjacencyGraphConcept
struct  AdjacencyMatrixConcept
class  aligned_storage
struct  alignment_of< T & >
struct  allow_parallel_edge_tag
class  any
struct  apply
class  apply_visitor_delayed_t
class  arg
struct  arithmetic1
struct  arithmetic2
class  array
class  array_view_gen
class  assignable_archetype
struct  AssignableConcept
class  associative_property_map
struct  AssociativeContainerConcept
struct  attributes_writer
struct  BackInsertionSequenceConcept
class  bad_any_cast
class  bad_expression
class  bad_function_call
class  bad_get
struct  bad_graph
class  bad_lexical_cast
class  bad_numeric_cast
class  bad_pattern
class  bad_rational
struct  bad_visit
class  bad_weak_ptr
class  barrier
class  base_from_member
struct  base_visitor
class  basic_format
class  basic_nullbuf
class  basic_onullstream
class  basic_regex
class  basic_wrap_stringstream
struct  BasicMatrixConcept
struct  bc_clustering_threshold
class  bellman_visitor
struct  BellmanFordVisitorConcept
class  bernoulli_distribution
class  bfs_visitor
struct  BFSVisitorConcept
struct  bgl_named_params
struct  bidir_adj_list_traversal_tag
struct  bidirectional_graph_helper
struct  bidirectional_graph_helper_with_property
struct  bidirectional_graph_tag
struct  bidirectional_iteratable
class  bidirectional_iterator_archetype
struct  bidirectional_iterator_helper
struct  bidirectional_tag
struct  bidirectional_traversal_tag
struct  BidirectionalGraphConcept
struct  BidirectionalIteratorConcept
struct  bidirectionalS
class  binary_function_archetype
class  binary_negate
class  binary_predicate_archetype
struct  binary_traits
struct  binary_traits< R(*)(A1, A2)>
struct  BinaryFunctionConcept
struct  BinaryFunctionConcept< Func, void, First, Second >
struct  BinaryPredicateConcept
class  binder1st
class  binder2nd
class  binomial_distribution
struct  bitwise1
struct  bitwise2
struct  blank
class  boolean_archetype
class  BOOST_FUNCTION_FUNCTION
struct  BOOST_ITERATOR_CATEGORY
class  BOOST_SIGNALS_SIGNAL
class  bucket_sorter
class  buffer_archetype
struct  buffer_param_t
struct  BufferConcept
struct  bundle_property_map
class  c_regex_traits< char >
class  c_regex_traits< regex_wchar_type >
class  c_regex_traits< wchar_t >
class  c_storage_order
struct  call_traits
struct  call_traits< const T[N]>
struct  call_traits< T & >
struct  call_traits< T[N]>
class  cauchy_distribution
class  char_delimiters_separator
class  char_separator
struct  checked_array_deleter
struct  checked_deleter
struct  choose_edge_property_map_archetype
struct  choose_vertex_property_map_archetype
struct  closed_plus
struct  color_traits
struct  color_traits< color_value_archetype >
struct  color_value_archetype
struct  ColorValueConcept
class  comparable_archetype
struct  ComparableConcept
class  component_index
class  compressed_pair
class  compressed_pair< T, T >
class  condition
struct  connects_predicate
class  const_array_view_gen
class  const_associative_property_map
struct  Const_BinaryPredicateConcept
class  const_mem_fun1_ref_t
class  const_mem_fun1_t
class  const_mem_fun_ref_t
class  const_mem_fun_t
class  const_multi_array_ref
class  const_subarray_gen
struct  container_gen
struct  container_gen< hash_mapS, ValueType >
struct  container_gen< hash_setS, ValueType >
struct  container_gen< list_with_allocatorS< Alloc >, ValueType >
struct  container_gen< listS, ValueType >
struct  container_gen< mapS, ValueType >
struct  container_gen< multisetS, ValueType >
struct  container_gen< ordered_set_by_nameS, ValueType >
struct  container_gen< setS, ValueType >
struct  container_gen< slistS, ValueType >
struct  container_gen< vecS, ValueType >
struct  ContainerConcept
class  convertible_from_archetype
class  convertible_to_archetype
struct  ConvertibleConcept
class  copy_constructible_archetype
struct  CopyConstructibleConcept
class  counting_iterator
class  cpp_regex_traits< char >
class  cpp_regex_traits< regex_wchar_type >
class  cpp_regex_traits< wchar_t >
class  crc_basic
class  crc_optimal
struct  ct_and
struct  ct_and< true_type, true_type >
struct  ct_if
struct  ct_if< false, A, B >
struct  ct_if< true, A, B >
struct  ct_if_error
struct  ct_if_t
struct  ct_if_t< false_type, A, B >
struct  ct_if_t< true_type, A, B >
struct  ct_not
struct  ct_not< false_type >
struct  ct_not< true_type >
struct  decrementable
struct  default_archetype_base
class  default_constructible_archetype
struct  default_user_allocator_malloc_free
struct  default_user_allocator_new_delete
struct  default_writer
struct  DefaultConstructibleConcept
class  degree_property_map
class  degree_vertex_invariant
struct  dereferenceable
class  dfs_visitor
class  DFSVisitorConcept
class  dijkstra_visitor
struct  DijkstraVisitorConcept
struct  directed_edges_helper
struct  directed_graph_helper
struct  directed_tag
struct  directedS
struct  disable_if
struct  disable_if_c
struct  disable_if_c< true, T >
struct  disallow_parallel_edge_tag
class  disjoint_sets
class  disjoint_sets_with_storage
struct  distance_combine_t
struct  distance_compare_t
struct  distance_inf_t
struct  distance_recorder
struct  distance_zero_t
struct  dummy_edge_predicate
class  dummy_property_map
struct  dummyT
class  dynamic_bitset
struct  edge_compare_t
struct  edge_component_t
struct  edge_copy_t
struct  edge_length_t
class  edge_list
struct  edge_list_edge_property_selector
struct  edge_list_graph_tag
class  edge_list_impl
class  edge_list_impl_ra
struct  edge_list_ra_edge_property_selector
struct  edge_list_ra_tag
struct  edge_list_tag
struct  edge_predecessor_recorder
class  edge_property
struct  edge_property< leda::GRAPH< vtype, etype > >
struct  edge_property_selector
struct  edge_property_selector< adj_list_tag >
struct  edge_property_selector< adjacency_matrix_class_tag >
struct  edge_property_selector< edge_list_ra_tag >
struct  edge_property_selector< edge_list_tag >
struct  edge_property_selector< filtered_graph_tag >
struct  edge_property_selector< graph_as_tree_tag >
struct  edge_property_selector< property_graph_archetype_tag >
struct  edge_property_selector< reverse_graph_tag >
struct  edge_property_selector< subgraph_tag >
struct  edge_property_selector< vec_adj_list_tag >
struct  edge_property_tag
struct  edge_property_type
struct  edge_property_type< std::vector< EdgeList > >
struct  EdgeListGraphConcept
struct  EdgeMutableGraphConcept
struct  EdgeMutablePropertyGraphConcept
struct  EdgePrinter
class  el_edge_property_map
class  el_ra_edge_property_map
struct  enable_if
struct  enable_if_c
struct  enable_if_c< false, T >
struct  enable_if_convertible
class  enable_shared_from_this
class  environment_iterator
class  eof_iterator
struct  equal_pointees_t
struct  equality_comparable1
struct  equality_comparable2
class  equality_comparable2_first_archetype
class  equality_comparable2_second_archetype
class  equality_comparable_archetype
struct  EqualityComparableConcept
struct  equivalent1
struct  equivalent2
struct  escaped_list_error
class  escaped_list_separator
struct  euclidian_ring_operators1
struct  euclidian_ring_operators2
class  execution_exception
class  execution_monitor
class  exponential_distribution
struct  false_tag
struct  false_type
class  fast_pool_allocator
struct  fast_pool_allocator_tag
class  fenced_priority_queue
class  fibonacci_heap
struct  field_operators1
struct  field_operators2
class  filter_iterator
class  filtered_graph
struct  filtered_graph_base
struct  filtered_graph_tag
struct  find_with_full_path_compression
struct  find_with_path_halving
class  fortran_storage_order
struct  forward_iteratable
class  forward_iterator_archetype
struct  forward_iterator_helper
struct  forward_traversal_tag
struct  ForwardContainerConcept
struct  ForwardIteratorConcept
struct  FrontInsertionSequenceConcept
class  function< BOOST_FUNCTION_PARTIAL_SPEC, Allocator >
class  function_base
class  function_output_iterator
struct  function_traits
class  gamma_distribution
class  general_storage_order
class  generator_archetype
class  generator_iterator
struct  generator_iterator_generator
class  generator_iterator_mixin_adapter
struct  GeneratorConcept
struct  GeneratorConcept< Func, void >
class  geometric_distribution
struct  get_vertex_sharing
class  graph_as_tree
class  graph_as_tree_base
struct  graph_as_tree_tag
struct  graph_attributes_writer
class  graph_property
class  graph_property_iter_range
struct  graph_property_tag
struct  graph_property_type
struct  graph_property_type< std::vector< EdgeList > >
struct  graph_test
struct  graph_traits
struct  graph_traits< leda::GRAPH< vtype, etype > >
struct  graph_traits< sgb_const_graph_ptr >
struct  graph_traits< sgb_graph_ptr >
struct  graph_traits< std::vector< EdgeList > >
struct  GraphConcept
struct  GraphParser
struct  GraphPrinter
struct  GraphPrinter< Graph, no_property, E >
struct  graphviz_io_traits
struct  graphviz_io_traits< undirected_tag >
struct  greater_than_type_max< false, false >
struct  greater_than_type_max< false, true >
struct  greater_than_type_max< true, false >
struct  greater_than_type_max< true, true >
struct  has_nothrow_copy< ::boost::detail::reference_content< T & > >
struct  has_property
struct  has_property< no_property >
struct  hash_mapS
struct  hash_setS
struct  high_bit_mask_t
struct  identity_property_map
class  in_place_factory_base
struct  incidence_graph_archetype
struct  incidence_graph_tag
struct  IncidenceGraphConcept
struct  incident_from_predicate
struct  incident_on_predicate
struct  incident_to_predicate
struct  incrementable
struct  incrementable_traversal_tag
struct  indexable
class  indirect_cmp
class  indirect_iterator
class  indirect_pmap
struct  indirect_reference
struct  input_iteratable
class  input_iterator_archetype
class  input_iterator_archetype_no_proxy
struct  input_iterator_helper
class  input_output_iterator_archetype
struct  InputIteratorConcept
struct  int_fast_t
struct  int_fast_t< short >
class  int_iterator
struct  int_least_helper
struct  int_least_helper< 1 >
struct  int_least_helper< 2 >
struct  int_least_helper< 3 >
struct  int_least_helper< 4 >
struct  int_least_helper< 6 >
struct  int_least_helper< 7 >
struct  int_least_helper< 8 >
struct  int_least_helper< 9 >
struct  int_max_value_t
struct  int_min_value_t
struct  int_t
struct  integer_arithmetic1
struct  integer_arithmetic2
struct  integer_multiplicative1
struct  integer_multiplicative2
struct  integer_range
class  integer_traits
class  integer_traits< bool >
class  integer_traits< char >
class  integer_traits< int >
class  integer_traits< long >
class  integer_traits< short >
class  integer_traits< signed char >
class  integer_traits< unsigned char >
class  integer_traits< unsigned int >
class  integer_traits< unsigned long >
class  integer_traits< unsigned short >
class  integer_traits< wchar_t >
struct  IntegerConcept
struct  IntegerConcept< int >
struct  IntegerConcept< long >
struct  IntegerConcept< short >
struct  IntegerConcept< unsigned int >
struct  IntegerConcept< unsigned long >
struct  IntegerConcept< unsigned short >
class  intrusive_ptr
struct  inv_adjacency_iterator
class  inv_adjacency_iterator_generator
class  invalid_thread_argument
struct  is_abstract
struct  is_big_char
struct  is_chained_base
struct  is_convertible< use_default, To >
struct  is_empty< blank >
struct  is_empty< empty_POD_UDT >
struct  is_empty< empty_UDT >
struct  is_in_subset
struct  is_interoperable
struct  is_not_in_subset
struct  is_pod< ::boost::detail::lower_alignment< Align > >
struct  is_pod< blank >
struct  is_POD< empty_POD_UDT >
struct  is_random
struct  is_random< std::random_access_iterator_tag >
struct  is_random_access_iterator
class  is_reference_wrapper
struct  is_residual_edge
struct  is_stateless< blank >
struct  is_stateless< stateless_integer_add >
struct  iterator
struct  iterator_access_archetype
struct  iterator_access_archetype_impl
struct  iterator_access_archetype_impl< iterator_archetypes::readable_iterator_t >
struct  iterator_access_archetype_impl< iterator_archetypes::readable_lvalue_iterator_t >
struct  iterator_access_archetype_impl< iterator_archetypes::readable_writable_iterator_t >
struct  iterator_access_archetype_impl< iterator_archetypes::writable_iterator_t >
struct  iterator_access_archetype_impl< iterator_archetypes::writable_lvalue_iterator_t >
class  iterator_adaptor
struct  iterator_archetype
struct  iterator_category_to_traversal
class  iterator_core_access
struct  iterator_difference
class  iterator_facade
struct  iterator_pointer
class  iterator_property_map
class  iterator_range
 iterator_range class More...
struct  iterator_reference
struct  iterator_traversal
struct  iterator_value
struct  keep_all
class  label_writer
struct  last_value
struct  last_value< void >
struct  layout_tolerance
 Determines when to terminate layout of a particular graph based on a given relative tolerance. More...
struct  lazy_disable_if
struct  lazy_disable_if_c
struct  lazy_disable_if_c< true, T >
struct  lazy_enable_if
struct  lazy_enable_if_c
struct  lazy_enable_if_c< false, T >
class  leda_graph_data_map
class  leda_graph_id_map
struct  leda_graph_traversal_category
class  leda_node_property_map
struct  leda_property_map
struct  leda_property_map< edge_all_t >
struct  leda_property_map< edge_index_t >
struct  leda_property_map< vertex_all_t >
struct  leda_property_map< vertex_index_t >
struct  less_pointees_t
struct  less_than_comparable1
struct  less_than_comparable2
class  less_than_comparable_archetype
struct  less_than_type_min
struct  less_than_type_min< false, true >
struct  less_than_type_min< true, false >
struct  LessThanComparableConcept
struct  line_property
struct  line_tag
struct  list_edge
struct  listS
class  lock_error
class  lognormal_distribution
struct  low_bits_mask_t
struct  lvalue_property_map_archetype
struct  lvalue_property_map_tag
struct  lvalue_test
struct  LvaluePropertyGraphConcept
struct  LvaluePropertyMapConcept
struct  make_recursive_variant
struct  make_recursive_variant_over
struct  make_variant_over
struct  mapS
class  match_results
class  matrix_adj_iterator
class  matrix_incidence_iterator
class  mem_fun1_ref_t
class  mem_fun1_t
class  mem_fun_ref_t
class  mem_fun_t
class  multi_array
class  multi_array_ref
struct  MultiPassInputIteratorConcept
struct  MultipleAssociativeContainerConcept
struct  multiplicative1
struct  multiplicative2
struct  multisetS
class  mutable_bidirectional_iterator_archetype
struct  Mutable_BidirectionalIteratorConcept
struct  Mutable_ContainerConcept
class  mutable_forward_iterator_archetype
struct  Mutable_ForwardContainerConcept
struct  Mutable_ForwardIteratorConcept
struct  mutable_lvalue_property_map_archetype
struct  Mutable_LvaluePropertyMapConcept
class  mutable_queue
class  mutable_random_access_iterator_archetype
struct  Mutable_RandomAccessContainerConcept
struct  Mutable_RandomAccessIteratorConcept
struct  Mutable_ReversibleContainerConcept
struct  MutableBidirectionalGraphConcept
struct  MutableEdgeListGraphConcept
struct  MutableGraphConcept
struct  MutableIncidenceGraphConcept
class  mutex
struct  negative_cycle
struct  negative_edge
class  neighbor_bfs_visitor
struct  NeighborBFSVisitorConcept
struct  no_property
struct  no_traversal_tag
struct  non_type
class  normal_distribution
struct  not_a_dag
struct  not_connected
class  null_archetype
struct  null_tree_visitor
struct  null_visitor
class  object_pool
class  offset_separator
struct  on_back_edge
struct  on_black_target
struct  on_discover_vertex
struct  on_edge_minimized
struct  on_edge_not_minimized
struct  on_edge_not_relaxed
struct  on_edge_relaxed
struct  on_examine_edge
struct  on_examine_vertex
struct  on_finish_vertex
struct  on_forward_or_cross_edge
struct  on_gray_target
struct  on_initialize_vertex
struct  on_no_event
struct  on_non_tree_edge
struct  on_start_vertex
struct  on_tree_edge
struct  operators
struct  operators2
struct  operators< T, T >
struct  optag1
struct  optag2
struct  optag3
class  optional
struct  ordered_euclidian_ring_operators1
struct  ordered_euclidian_ring_operators2
struct  ordered_field_operators1
struct  ordered_field_operators2
struct  ordered_ring_operators1
struct  ordered_ring_operators2
struct  orig_to_copy_t
struct  output_iteratable
class  output_iterator_archetype
struct  output_iterator_helper
struct  output_proxy
struct  OutputIteratorConcept
struct  PairAssociativeContainerConcept
struct  parallel_edge_traits
struct  parallel_edge_traits< hash_mapS >
struct  parallel_edge_traits< hash_setS >
struct  parallel_edge_traits< list_with_allocatorS< Alloc > >
struct  parallel_edge_traits< listS >
struct  parallel_edge_traits< mapS >
struct  parallel_edge_traits< multisetS >
struct  parallel_edge_traits< ordered_set_by_nameS >
struct  parallel_edge_traits< setS >
struct  parallel_edge_traits< slistS >
struct  parallel_edge_traits< vecS >
struct  partially_ordered1
struct  partially_ordered2
class  permutation_iterator
struct  pfto_wrapper
struct  pointee
class  pointer_to_binary_function
class  pointer_to_unary_function
class  poisson_distribution
class  pool
class  pool_allocator
struct  pool_allocator_tag
struct  predecessor_recorder
class  progress_display
class  progress_timer
struct  property
struct  property_graph_archetype
struct  property_graph_archetype_tag
struct  property_kind
struct  property_map
struct  property_map< Graph, T Bundle::* >
struct  property_map< leda::GRAPH< vtype, etype >, Tag >
struct  property_map< sgb_const_graph_ptr, edge_length_t >
struct  property_map< sgb_const_graph_ptr, PropertyTag >
struct  property_map< sgb_const_graph_ptr, vertex_index_t >
struct  property_map< sgb_const_graph_ptr, vertex_name_t >
struct  property_map< sgb_graph_ptr, edge_length_t >
struct  property_map< sgb_graph_ptr, PropertyTag >
struct  property_map< sgb_graph_ptr, vertex_index_t >
struct  property_map< sgb_graph_ptr, vertex_name_t >
struct  property_map_iterator_generator
class  property_map_value
struct  property_traits
struct  property_traits< const T * >
struct  property_traits< T * >
struct  property_value
struct  property_writer
struct  PropertyGraphConcept
struct  PropertyPrinter
struct  PropertyPrinter< Graph, no_property >
struct  put_get_helper
class  queue
class  rand48
struct  random_access_iteratable
class  random_access_iterator_archetype
struct  random_access_iterator_helper
struct  random_access_traversal_tag
class  random_device
class  random_number_generator
struct  RandomAccessContainerConcept
struct  RandomAccessIteratorConcept
class  range_const_iterator
struct  range_const_iterator< char * >
struct  range_const_iterator< const char * >
struct  range_const_iterator< const std::pair< Iterator, Iterator > >
struct  range_const_iterator< const T[sz] >
struct  range_const_iterator< const wchar_t * >
struct  range_const_iterator< std::pair< Iterator, Iterator > >
struct  range_const_iterator< T[sz] >
struct  range_const_iterator< wchar_t * >
struct  range_const_reverse_iterator
struct  range_difference
struct  range_difference< char * >
struct  range_difference< const char * >
struct  range_difference< const std::pair< Iterator, Iterator > >
struct  range_difference< const T[sz] >
struct  range_difference< const wchar_t * >
struct  range_difference< std::pair< Iterator, Iterator > >
struct  range_difference< T[sz] >
struct  range_difference< wchar_t * >
struct  range_iterator
struct  range_iterator< char * >
struct  range_iterator< const char * >
struct  range_iterator< const std::pair< Iterator, Iterator > >
struct  range_iterator< const T[sz] >
struct  range_iterator< const wchar_t * >
struct  range_iterator< std::pair< Iterator, Iterator > >
struct  range_iterator< T[sz] >
struct  range_iterator< wchar_t * >
struct  range_result_iterator
struct  range_reverse_iterator
struct  range_reverse_result_iterator
struct  range_size
struct  range_size< char * >
struct  range_size< const char * >
struct  range_size< const std::pair< Iterator, Iterator > >
struct  range_size< const T[sz] >
struct  range_size< const wchar_t * >
struct  range_size< std::pair< Iterator, Iterator > >
struct  range_size< T[sz] >
struct  range_size< wchar_t * >
struct  range_value
struct  range_value< char * >
struct  range_value< const char * >
struct  range_value< const std::pair< Iterator, Iterator > >
struct  range_value< const T[sz] >
struct  range_value< const wchar_t * >
struct  range_value< std::pair< Iterator, Iterator > >
struct  range_value< T[sz] >
struct  range_value< wchar_t * >
class  rational
class  read_write_mutex
struct  read_write_property_map_archetype
struct  read_write_property_map_tag
struct  readable_property_map_archetype
struct  readable_property_map_tag
struct  ReadablePropertyGraphConcept
struct  ReadablePropertyMapConcept
struct  ReadWritePropertyMapConcept
class  recursive_mutex
class  recursive_timed_mutex
class  recursive_try_mutex
class  recursive_wrapper
class  reference_wrapper
class  reg_expression
class  regbase
class  regex_iterator
class  regex_iterator_implementation
class  regex_token_iterator
class  regex_token_iterator_implementation
struct  require_same
struct  require_same< T, T >
class  reverse_graph
struct  reverse_graph_tag
class  reverse_iterator
struct  ReversibleContainerConcept
struct  ring_operators1
struct  ring_operators2
struct  root_vertex_t
class  safe_iterator_property_map
class  SAW_visitor
class  scoped_array
class  scoped_ptr
struct  SequenceConcept
struct  setS
class  sgb_edge
class  sgb_edge_length_map
class  sgb_edge_util_map
struct  sgb_traversal_tag
class  sgb_vertex_id_map
class  sgb_vertex_name_map
class  sgb_vertex_util_map
class  sgi_assignable_archetype
struct  SGIAssignableConcept
struct  shadow_cmp
struct  shadow_iterator_generator
class  shared_array
class  shared_container_iterator
class  shared_ptr
struct  shiftable1
struct  shiftable2
class  signal
struct  SignedIntegerConcept
struct  SignedIntegerConcept< int >
struct  SignedIntegerConcept< long >
struct  SignedIntegerConcept< short >
class  simple_segregated_storage
struct  SimpleAssociativeContainerConcept
struct  single_pass_traversal_tag
struct  singleton_pool
struct  slistS
class  slot
struct  SortedAssociativeContainerConcept
struct  spoiler1
class  state_saver
struct  static_assert_test
struct  STATIC_ASSERTION_FAILURE< true >
struct  static_log2
struct  static_log2< 0 >
class  static_object
struct  static_signed_max
struct  static_signed_min
struct  static_unsigned_max
struct  static_unsigned_min
class  static_visitor
struct  static_warning_impl< false >
struct  static_warning_impl< true >
struct  sub_match
class  sub_range
class  subarray_gen
class  subgraph
class  subgraph_global_property_map
class  subgraph_local_property_map
struct  subgraph_tag
class  thread
class  thread_exception
class  thread_group
class  thread_permission_error
class  thread_resource_error
class  thread_specific_ptr
struct  time_stamper
class  timed_mutex
class  timed_read_write_mutex
class  timer
class  token_iterator
class  token_iterator_generator
class  tokenizer
struct  topo_sort_visitor
struct  totally_ordered1
struct  totally_ordered2
class  transform_iterator
struct  traversal_archetype_base
struct  tree_traits
class  triangle_distribution
struct  triangle_tag
struct  triple
struct  true_tag
struct  true_type
class  try_mutex
class  try_read_write_mutex
struct  type
class  type_with_alignment
class  typed_in_place_factory_base
struct  uint_t
struct  uint_value_t
class  unary_function_archetype
class  unary_negate
class  unary_predicate_archetype
struct  unary_traits
struct  unary_traits< R(*)(A)>
struct  UnaryFunctionConcept
struct  UnaryFunctionConcept< Func, void, Arg >
struct  UnaryPredicateConcept
struct  undir_adj_list_traversal_tag
struct  undirected_graph_helper
struct  undirected_tag
struct  undirectedS
class  uniform_01
class  uniform_int
class  uniform_on_sphere
class  uniform_real
class  uniform_smallint
struct  UniqueAssociativeContainerConcept
struct  unit_steppable
struct  UnsignedIntegerConcept
struct  UnsignedIntegerConcept< unsigned int >
struct  UnsignedIntegerConcept< unsigned long >
struct  UnsignedIntegerConcept< unsigned short >
class  unsupported_thread_option
struct  unwrap_recursive< recursive_wrapper< T > >
class  unwrap_reference
class  value_initialized
class  variant
class  variate_generator
struct  vec_adj_list_all_vertex_pa
struct  vec_adj_list_any_vertex_pa
struct  vec_adj_list_id_vertex_pa
class  vec_adj_list_impl
struct  vec_adj_list_tag
struct  vec_adj_list_vertex_all_properties_map
struct  vec_adj_list_vertex_id_map
struct  vec_adj_list_vertex_property_map
struct  vec_adj_list_vertex_property_selector
struct  vecS
struct  vector_as_graph_traversal_tag
class  vector_property_map
struct  vertex_copy_t
struct  vertex_invariant1_t
struct  vertex_invariant2_t
struct  vertex_invariant_t
struct  vertex_isomorphism_t
struct  vertex_list_graph_archetype
struct  vertex_list_graph_tag
struct  vertex_max_invariant_t
class  vertex_property
struct  vertex_property< leda::GRAPH< vtype, etype > >
struct  vertex_property_selector
struct  vertex_property_selector< adj_list_tag >
struct  vertex_property_selector< adjacency_matrix_class_tag >
struct  vertex_property_selector< filtered_graph_tag >
struct  vertex_property_selector< graph_as_tree_tag >
struct  vertex_property_selector< property_graph_archetype_tag >
struct  vertex_property_selector< reverse_graph_tag >
struct  vertex_property_selector< subgraph_tag >
struct  vertex_property_selector< vec_adj_list_tag >
struct  vertex_property_tag
struct  vertex_property_type
struct  vertex_property_type< std::vector< EdgeList > >
struct  vertex_subset_compliment_filter
struct  vertex_subset_filter
struct  VertexAndEdgeListGraphConcept
struct  VertexListGraphConcept
struct  VertexMutableGraphConcept
struct  VertexMutablePropertyGraphConcept
class  visitor_ptr_t
class  void_generator_archetype
class  weak_ptr
struct  writable_property_map_archetype
struct  writable_property_map_tag
struct  WritablePropertyMapConcept
struct  xtime
class  zip_iterator

Namespaces

namespace  CV
 Namespace containing constrained_value template and types.
namespace  gregorian
 Gregorian date system based on date_time components.
namespace  posix_time
 Defines a non-adjusted time system with nano-second resolution and stable calculation properties.
namespace  program_options

Typedefs

typedef std::vector
< cache_element > 
cache_t
typedef void *(* cast_function )(void *)
typedef adjacency_list< vecS,
vecS, bidirectionalS,
no_property, property
< edge_index_t, std::size_t,
property< edge_cast_t,
cast_function > > > 
cast_graph
typedef wchar_t char_type
typedef python::type_info class_id
typedef crc_optimal< 16, 0x8005, 0, 0, true, true > crc_16_type
typedef crc_optimal< 32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true, true > crc_32_type
typedef crc_optimal< 16, 0x1021, 0xFFFF, 0, false, false > crc_ccitt_type
typedef crc_optimal< 16, 0x8408, 0, 0, true, true > crc_xmodem_type
typedef regex_iterator< const
char * > 
cregex_iterator
typedef regex_token_iterator
< const char * > 
cregex_token_iterator
typedef bellman_visitor default_bellman_visitor
typedef bfs_visitor default_bfs_visitor
typedef dfs_visitor default_dfs_visitor
typedef dijkstra_visitor default_dijkstra_visitor
typedef
random::additive_combine
< random::linear_congruential
< int32_t, 40014, 0, 2147483563, 0 >
, random::linear_congruential
< int32_t, 40692, 0, 2147483399, 0 >, 2060321752 > 
ecuyer1988
typedef cast_graph::edge_descriptor edge_t
typedef basic_format< char > format
typedef std::map< std::string,
std::string > 
GraphvizAttrList
typedef subgraph
< adjacency_list< vecS, vecS,
directedS,
GraphvizVertexProperty,
GraphvizEdgeProperty,
GraphvizGraphProperty > > 
GraphvizDigraph
typedef property
< edge_attribute_t,
GraphvizAttrList, property
< edge_index_t, int > > 
GraphvizEdgeProperty
typedef subgraph
< adjacency_list< vecS, vecS,
undirectedS,
GraphvizVertexProperty,
GraphvizEdgeProperty,
GraphvizGraphProperty > > 
GraphvizGraph
typedef property
< graph_graph_attribute_t,
GraphvizAttrList, property
< graph_vertex_attribute_t,
GraphvizAttrList, property
< graph_edge_attribute_t,
GraphvizAttrList, property
< graph_name_t, std::string > > > > 
GraphvizGraphProperty
typedef property
< vertex_attribute_t,
GraphvizAttrList > 
GraphvizVertexProperty
typedef
random::inversive_congruential
< int32_t, 9102, 2147483647-36884165, 2147483647, 0 > 
hellekalek1995
typedef
index_entry_interface::inherited 
index_entry
typedef tuples::tuple
< class_id, vertex_t,
dynamic_id_function > 
index_entry_interface
typedef random::shuffle_output
< random::linear_congruential
< uint32_t, 1366, 150889, 714025, 0 >, 97, 139726 > 
kreutzer1986
typedef
random::lagged_fibonacci_01
< double, 48, 1279, 418 > 
lagged_fibonacci1279
typedef
random::lagged_fibonacci_01
< double, 48, 19937, 9842 > 
lagged_fibonacci19937
typedef
random::lagged_fibonacci_01
< double, 48, 2281, 1252 > 
lagged_fibonacci2281
typedef
random::lagged_fibonacci_01
< double, 48, 23209, 13470 > 
lagged_fibonacci23209
typedef
random::lagged_fibonacci_01
< double, 48, 3217, 576 > 
lagged_fibonacci3217
typedef
random::lagged_fibonacci_01
< double, 48, 4423, 2098 > 
lagged_fibonacci4423
typedef
random::lagged_fibonacci_01
< double, 48, 44497, 21034 > 
lagged_fibonacci44497
typedef
random::lagged_fibonacci_01
< double, 48, 607, 273 > 
lagged_fibonacci607
typedef
random::lagged_fibonacci_01
< double, 48, 9689, 5502 > 
lagged_fibonacci9689
typedef
random::linear_congruential
< int32_t, 48271, 0, 2147483647, 399268537 > 
minstd_rand
typedef
random::linear_congruential
< int32_t, 16807, 0, 2147483647, 1043618065 > 
minstd_rand0
typedef
random::mersenne_twister
< uint32_t, 32, 351, 175, 19, 0xccab8ee7, 11, 7, 0x31b6ab00, 15, 0xffe50000, 17, 0xa37d3c92 > 
mt11213b
typedef
random::mersenne_twister
< uint32_t, 32, 624, 397, 31, 0x9908b0df, 11, 7, 0x9d2c5680, 15, 0xefc60000, 18, 3346425566U > 
mt19937
typedef
boost::forward_traversal_tag 
multi_pass_input_iterator_tag
typedef noncopyable_::noncopyable noncopyable
typedef basic_nullbuf< char > nullbuf
typedef basic_onullstream< char > onullstream
typedef bool(* pred1_type )(const match_results< ra_it > &)
typedef bool(* pred2_type )(const match_results< test_string_type::const_iterator > &)
typedef const char * ra_it
typedef random::discard_block
< random::ranlux_base, 223, 24 > 
ranlux3
typedef random::discard_block
< random::ranlux_base_01, 223, 24 > 
ranlux3_01
typedef random::discard_block
< random::ranlux_base, 389, 24 > 
ranlux4
typedef random::discard_block
< random::ranlux_base_01, 389, 24 > 
ranlux4_01
typedef random::discard_block
< random::ranlux64_base, 223, 24 > 
ranlux64_3
typedef random::discard_block
< random::ranlux64_base_01, 223, 24 > 
ranlux64_3_01
typedef random::discard_block
< random::ranlux64_base, 389, 24 > 
ranlux64_4
typedef random::discard_block
< random::ranlux64_base_01, 389, 24 > 
ranlux64_4_01
typedef reg_expression< char,
regex_traits< char >
, BOOST_DEFAULT_ALLOCATOR(char) > 
regex
typedef const Graph * sgb_const_graph_ptr
typedef Graph * sgb_graph_ptr
typedef regex_iterator
< std::string::const_iterator > 
sregex_iterator
typedef regex_token_iterator
< std::string::const_iterator > 
sregex_token_iterator
typedef
detail::static_log2_impl::argument_type 
static_log2_argument_type
typedef
detail::static_log2_impl::result_type 
static_log2_result_type
typedef random::xor_combine
< random::xor_combine
< random::linear_feedback_shift
< uint32_t, 32, 31, 13, 12, 0 >
, 0, random::linear_feedback_shift
< uint32_t, 32, 29, 2, 4, 0 >
, 0, 0 >, 0, random::linear_feedback_shift
< uint32_t, 32, 28, 3, 17, 0 >, 0, 0 > 
taus88
typedef char test_char_type
typedef std::basic_string
< test_char_type > 
test_string_type
typedef property< triangle_tag,
Triple > 
triangle_property
typedef triple< int, int, int > Triple
typedef std::pair
< type_index_t::iterator,
type_index_t::iterator > 
type_index_iterator_pair
typedef std::vector< index_entry > type_index_t
typedef
cast_graph::vertex_descriptor 
vertex_t
typedef regex_iterator< const
wchar_t * > 
wcregex_iterator
typedef regex_token_iterator
< const wchar_t * > 
wcregex_token_iterator
typedef basic_format< wchar_t > wformat
typedef basic_nullbuf< wchar_t > wnullbuf
typedef basic_onullstream
< wchar_t > 
wonullstream
typedef
basic_wrap_stringstream< char > 
wrap_stringstream
typedef
basic_wrap_stringstream
< wchar_t > 
wrap_wstringstream
typedef reg_expression
< wchar_t, regex_traits
< wchar_t >
, BOOST_DEFAULT_ALLOCATOR(wchar_t) > 
wregex
typedef regex_iterator
< std::wstring::const_iterator > 
wsregex_iterator
typedef regex_token_iterator
< std::wstring::const_iterator > 
wsregex_token_iterator

Enumerations

enum  default_color_type {
  white_color, gray_color, green_color, red_color,
  black_color
}
enum  edge_attribute_t { edge_attribute = 1111 }
enum  empty_token_policy { drop_empty_tokens, keep_empty_tokens }
enum  format_flags_t {
  format_all = 0, format_sed = match_max << 1, format_perl = format_sed << 1, format_no_copy = format_perl << 1,
  format_first_only = format_no_copy << 1, format_is_if = format_first_only << 1
}
enum  graph_edge_attribute_t { graph_edge_attribute = 5555 }
enum  graph_graph_attribute_t { graph_graph_attribute = 3333 }
enum  graph_vertex_attribute_t { graph_vertex_attribute = 4444 }
enum  vertex_attribute_t { vertex_attribute = 2222 }
enum  vertex_compile_cost_t { vertex_compile_cost, vertex_compile_cost }
enum  vertex_compile_cost_t { vertex_compile_cost, vertex_compile_cost }
enum  xtime_clock_types { TIME_UTC = 1 }

Functions

template<typename IntType>
rational< IntType > abs (const rational< IntType > &r)
template<class EdgeList, class Allocator>
std::pair< typename
detail::val_edge< EdgeList >
::type, bool > 
add_edge (typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector< EdgeList, Allocator > &g)
template<typename G>
std::pair< typename subgraph
< G >::edge_descriptor, bool > 
add_edge (typename subgraph< G >::vertex_descriptor u, typename subgraph< G >::vertex_descriptor v, subgraph< G > &g)
template<typename G>
std::pair< typename subgraph
< G >::edge_descriptor, bool > 
add_edge (typename subgraph< G >::vertex_descriptor u_local, typename subgraph< G >::vertex_descriptor v_local, const typename G::edge_property_type &ep, subgraph< G > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::edge_descriptor, bool > 
add_edge (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor v, const etype &et, leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::edge_descriptor, bool > 
add_edge (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor v, leda::GRAPH< vtype, etype > &g)
template<class Graph, class Config, class Base>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, vec_adj_list_impl< Graph, Config, Base > &g_)
template<class Graph, class Config, class Base>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const typename Config::edge_property_type &p, vec_adj_list_impl< Graph, Config, Base > &g_)
template<class Config>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const typename Config::edge_property_type &p, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, undirected_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const typename Config::edge_property_type &p, undirected_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, directed_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
directed_graph_helper< Config >
::edge_descriptor, bool > 
add_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const typename Config::edge_property_type &p, directed_graph_helper< Config > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::edge_descriptor, bool > 
add_edge (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor v, adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::edge_descriptor, bool > 
add_edge (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor v, const EP &ep, adjacency_matrix< D, VP, EP, GP, A > &g)
re_detail::re_syntax_base * add_offset (void *base, std::ptrdiff_t off)
template<class EdgeList, class Allocator>
EdgeList::value_type add_vertex (std::vector< EdgeList, Allocator > &g)
template<typename G>
subgraph< G >::vertex_descriptor add_vertex (subgraph< G > &g)
template<typename G>
subgraph< G >::vertex_descriptor add_vertex (typename subgraph< G >::vertex_descriptor u_global, subgraph< G > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_descriptor 
add_vertex (const vtype &vp, leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_descriptor 
add_vertex (leda::GRAPH< vtype, etype > &g)
template<class Graph, class Config, class Base>
Config::vertex_descriptor add_vertex (const typename Config::vertex_property_type &p, vec_adj_list_impl< Graph, Config, Base > &g_)
template<class Graph, class Config, class Base>
Config::vertex_descriptor add_vertex (vec_adj_list_impl< Graph, Config, Base > &g_)
template<class Derived, class Config, class Base>
Config::vertex_descriptor add_vertex (const typename Config::vertex_property_type &p, adj_list_impl< Derived, Config, Base > &g_)
template<class Derived, class Config, class Base>
Config::vertex_descriptor add_vertex (adj_list_impl< Derived, Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::vertex_descriptor 
add_vertex (const VP &vp, adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::vertex_descriptor 
add_vertex (adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename T>
T * addressof (T &v)
template<class EdgeList, class Alloc>
std::pair< typename
EdgeList::const_iterator,
typename
EdgeList::const_iterator > 
adjacent_vertices (typename EdgeList::value_type v, const std::vector< EdgeList, Alloc > &g)
template<typename G>
std::pair< typename subgraph
< G >::adjacency_iterator,
typename subgraph< G >
::adjacency_iterator > 
adjacent_vertices (typename subgraph< G >::vertex_descriptor u_local, const subgraph< G > &g)
std::pair< sgb_adj_iterator,
sgb_adj_iterator > 
adjacent_vertices (Vertex *u, sgb_const_graph_ptr)
template<class BidirectionalGraph, class GRef>
std::pair< typename
reverse_graph
< BidirectionalGraph, GRef >
::adjacency_iterator, typename
reverse_graph
< BidirectionalGraph, GRef >
::adjacency_iterator > 
adjacent_vertices (const typename BidirectionalGraph::vertex_descriptor u, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::adjacency_iterator,
typename graph_traits
< leda::GRAPH< vtype, etype >
>::adjacency_iterator > 
adjacent_vertices (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &g)
template<typename V, typename D, typename P, typename B>
std::pair< typename
adjacency_graph_archetype< V,
D, P, B >::adjacency_iterator,
typename
adjacency_graph_archetype< V,
D, P, B >::adjacency_iterator > 
adjacent_vertices (const V &, const adjacency_graph_archetype< V, D, P, B > &)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::adjacency_iterator, typename
filtered_graph< G, EP, VP >
::adjacency_iterator > 
adjacent_vertices (typename filtered_graph< G, EP, VP >::vertex_descriptor u, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
std::pair< typename
Config::adjacency_iterator,
typename
Config::adjacency_iterator > 
adjacent_vertices (typename Config::vertex_descriptor u, const adj_list_helper< Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::adjacency_iterator,
typename adjacency_matrix< D,
VP, EP, GP, A >
::adjacency_iterator > 
adjacent_vertices (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, const adjacency_matrix< D, VP, EP, GP, A > &g_)
template<typename Container, typename Predicate>
bool all (const Container &c, Predicate p)
template<typename InputIterator, typename Predicate>
bool all (InputIterator first, InputIterator last, Predicate p)
template<typename Graph>
bool allows_parallel_edges (const Graph &)
template<typename ValueType>
ValueType any_cast (const any &operand)
template<typename ValueType>
const ValueType * any_cast (const any *operand)
template<typename ValueType>
ValueType * any_cast (any *operand)
template<typename Container, typename Predicate>
bool any_if (const Container &c, Predicate p)
template<typename InputIterator, typename Predicate>
bool any_if (InputIterator first, InputIterator last, Predicate p)
template<typename Visitor, typename Visitable>
 apply_visitor (const Visitor &visitor, Visitable &visitable)
template<typename Visitor, typename Visitable>
 apply_visitor (Visitor &visitor, Visitable &visitable)
template<typename Visitor>
apply_visitor_delayed_t< Visitor > apply_visitor (Visitor &visitor)
template<typename Visitor, typename Visitable1, typename Visitable2>
 apply_visitor (Visitor &visitor, Visitable1 &visitable1, Visitable2 &visitable2)
void assertion_failed (char const *expr, char const *func, char const *file, long)
template<std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly>
uint_t< Bits >::fast augmented_crc (void const *buffer, std::size_t byte_count BOOST_ACRC_DUMMY_PARM_TYPE)
template<std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly>
uint_t< Bits >::fast augmented_crc (void const *buffer, std::size_t byte_count, typename uint_t< Bits >::fast initial_remainder BOOST_ACRC_DUMMY_PARM_TYPE)
template<typename Graph>
double aver_wavefront (const Graph &g)
template<typename Graph, typename VertexIndexMap>
double aver_wavefront (const Graph &g, VertexIndexMap index)
template<typename Graph>
graph_traits< Graph >
::vertices_size_type 
bandwidth (const Graph &g)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
bandwidth (const Graph &g, VertexIndexMap index)
template<class Range>
Range::iterator begin (const Range &r)
template<class Range>
Range::iterator begin (Range &r)
template<typename C>
BOOST_DEDUCED_TYPENAME
range_result_iterator< C >
::type 
begin (C &c)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_iterator< T >
::type 
begin (const T &r)
template<class T>
BOOST_DEDUCED_TYPENAME
range_iterator< T >::type 
begin (T &r)
template<typename T>
std::vector< T >::const_iterator begin (const std::vector< T > &c)
template<typename T>
std::vector< T >::iterator begin (std::vector< T > &c)
template<typename Iter1, typename Iter2>
Iter1 begin (const std::pair< Iter1, Iter2 > &p)
template<class EdgeListGraph, class Size>
bool bellman_ford_shortest_paths (EdgeListGraph &g, Size N)
template<class EdgeListGraph, class Size, class P, class T, class R>
bool bellman_ford_shortest_paths (EdgeListGraph &g, Size N, const bgl_named_params< P, T, R > &params)
template<class EdgeListGraph, class Size, class WeightMap, class PredecessorMap, class DistanceMap, class BinaryFunction, class BinaryPredicate, class BellmanFordVisitor>
bool bellman_ford_shortest_paths (EdgeListGraph &g, Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance, BinaryFunction combine, BinaryPredicate compare, BellmanFordVisitor v)
template<typename MutableGraph, typename Done>
void betweenness_centrality_clustering (MutableGraph &g, Done done)
template<typename MutableGraph, typename Done, typename EdgeCentralityMap>
void betweenness_centrality_clustering (MutableGraph &g, Done done, EdgeCentralityMap edge_centrality)
template<typename MutableGraph, typename Done, typename EdgeCentralityMap, typename VertexIndexMap>
void betweenness_centrality_clustering (MutableGraph &g, Done done, EdgeCentralityMap edge_centrality, VertexIndexMap vertex_index)
template<typename Graph, typename ComponentMap, typename DiscoverTimeMap, typename LowPointMap>
void biconnected_components (typename graph_traits< Graph >::vertex_descriptor v, typename graph_traits< Graph >::vertex_descriptor u, const Graph &g, ComponentMap comp, std::size_t &num_components, DiscoverTimeMap discover_time, LowPointMap lowpt)
template<class Iterator, class T>
void bidirectional_iterator_test (Iterator i, T v1, T v2)
template<class Iterator, class T>
void bidirectional_readable_iterator_test (Iterator i, T v1, T v2)
template<class Operation, class T>
binder1st< Operation > bind1st (const Operation &op, const T &x)
template<class Operation>
binder1st< Operation > bind1st (Operation &op, typename call_traits< typename binary_traits< Operation >::first_argument_type >::param_type x)
template<class Operation>
binder1st< Operation > bind1st (const Operation &op, typename call_traits< typename binary_traits< Operation >::first_argument_type >::param_type x)
template<class Operation>
binder2nd< Operation > bind2nd (Operation &op, typename call_traits< typename binary_traits< Operation >::second_argument_type >::param_type x)
template<class Operation>
binder2nd< Operation > bind2nd (const Operation &op, typename call_traits< typename binary_traits< Operation >::second_argument_type >::param_type x)
default_color_type black (default_color_type)
template<class R, class T, class A1>
_bi::bind_t< R, _mfi::dm< R, T >
, typename _bi::list_av_1< A1 >
::type > 
BOOST_BIND (R T::*f, A1 a1)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t< R, F, typename
_bi::list_av_9< A1, A2, A3, A4,
A5, A6, A7, A8, A9 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t< R, F, typename
_bi::list_av_8< A1, A2, A3, A4,
A5, A6, A7, A8 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t< R, F, typename
_bi::list_av_7< A1, A2, A3, A4,
A5, A6, A7 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t< R, F, typename
_bi::list_av_6< A1, A2, A3, A4,
A5, A6 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
template<class R, class F, class A1, class A2, class A3, class A4, class A5>
_bi::bind_t< R, F, typename
_bi::list_av_5< A1, A2, A3, A4,
A5 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
template<class R, class F, class A1, class A2, class A3, class A4>
_bi::bind_t< R, F, typename
_bi::list_av_4< A1, A2, A3, A4 >
::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3, A4 a4)
template<class R, class F, class A1, class A2, class A3>
_bi::bind_t< R, F, typename
_bi::list_av_3< A1, A2, A3 >
::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2, A3 a3)
template<class R, class F, class A1, class A2>
_bi::bind_t< R, F, typename
_bi::list_av_2< A1, A2 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1, A2 a2)
template<class R, class F, class A1>
_bi::bind_t< R, F, typename
_bi::list_av_1< A1 >::type > 
BOOST_BIND (boost::type< R >, F f, A1 a1)
template<class R, class F>
_bi::bind_t< R, F, _bi::list0 > BOOST_BIND (boost::type< R >, F f)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t< R, F, typename
_bi::list_av_9< A1, A2, A3, A4,
A5, A6, A7, A8, A9 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t< R, F, typename
_bi::list_av_8< A1, A2, A3, A4,
A5, A6, A7, A8 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t< R, F, typename
_bi::list_av_7< A1, A2, A3, A4,
A5, A6, A7 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t< R, F, typename
_bi::list_av_6< A1, A2, A3, A4,
A5, A6 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
template<class R, class F, class A1, class A2, class A3, class A4, class A5>
_bi::bind_t< R, F, typename
_bi::list_av_5< A1, A2, A3, A4,
A5 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
template<class R, class F, class A1, class A2, class A3, class A4>
_bi::bind_t< R, F, typename
_bi::list_av_4< A1, A2, A3, A4 >
::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4)
template<class R, class F, class A1, class A2, class A3>
_bi::bind_t< R, F, typename
_bi::list_av_3< A1, A2, A3 >
::type > 
BOOST_BIND (F f, A1 a1, A2 a2, A3 a3)
template<class R, class F, class A1, class A2>
_bi::bind_t< R, F, typename
_bi::list_av_2< A1, A2 >::type > 
BOOST_BIND (F f, A1 a1, A2 a2)
template<class R, class F, class A1>
_bi::bind_t< R, F, typename
_bi::list_av_1< A1 >::type > 
BOOST_BIND (F f, A1 a1)
template<class R, class F>
_bi::bind_t< R, F, _bi::list0 > BOOST_BIND (F f)
 BOOST_DEF_PROPERTY (edge, bundle)
 BOOST_DEF_PROPERTY (vertex, bundle)
 BOOST_DEF_PROPERTY (graph, visitor)
 BOOST_DEF_PROPERTY (edge, centrality)
 BOOST_DEF_PROPERTY (edge, residual_capacity)
 BOOST_DEF_PROPERTY (edge, capacity)
 BOOST_DEF_PROPERTY (edge, reverse)
 BOOST_DEF_PROPERTY (vertex, centrality)
 BOOST_DEF_PROPERTY (vertex, rank)
 BOOST_DEF_PROPERTY (vertex, predecessor)
 BOOST_DEF_PROPERTY (vertex, finish_time)
 BOOST_DEF_PROPERTY (vertex, discover_time)
 BOOST_DEF_PROPERTY (vertex, priority)
 BOOST_DEF_PROPERTY (vertex, current_degree)
 BOOST_DEF_PROPERTY (vertex, out_degree)
 BOOST_DEF_PROPERTY (vertex, in_degree)
 BOOST_DEF_PROPERTY (vertex, degree)
 BOOST_DEF_PROPERTY (vertex, color)
 BOOST_DEF_PROPERTY (vertex, distance)
 BOOST_DEF_PROPERTY (graph, name)
 BOOST_DEF_PROPERTY (vertex, name)
 BOOST_DEF_PROPERTY (edge, color)
 BOOST_DEF_PROPERTY (edge, weight2)
 BOOST_DEF_PROPERTY (edge, weight)
 BOOST_DEF_PROPERTY (edge, name)
 BOOST_DEF_PROPERTY (edge, index)
 BOOST_DEF_PROPERTY (vertex, root)
 BOOST_DEF_PROPERTY (vertex, index2)
 BOOST_DEF_PROPERTY (vertex, index1)
 BOOST_DEF_PROPERTY (vertex, index)
 BOOST_DEF_PROPERTY (graph, all)
 BOOST_DEF_PROPERTY (edge, all)
 BOOST_DEF_PROPERTY (vertex, all)
 BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT (%, ModOpConcept)
 BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT (-, SubtractOpConcept)
 BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT (/, DivideOpConcept)
 BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT (+, PlusOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (>=, GreaterEqualOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (>, GreaterThanOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (<=, LessEqualOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (<, LessThanOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (!=, NotEqualOpConcept)
 BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT (==, EqualOpConcept)
 BOOST_INSTALL_PROPERTY (edge, cast)
 BOOST_INSTALL_PROPERTY (edge, info)
 BOOST_INSTALL_PROPERTY (vertex, info)
 BOOST_INSTALL_PROPERTY (vertex, position)
 BOOST_INSTALL_PROPERTY (edge, id)
 BOOST_INSTALL_PROPERTY (vertex, id)
 BOOST_INSTALL_PROPERTY (vertex, first_name)
 BOOST_INSTALL_PROPERTY (edge, mycapacity)
 BOOST_INSTALL_PROPERTY (edge, myflow)
 BOOST_INSTALL_PROPERTY (vertex, compile_cost)
 BOOST_INSTALL_PROPERTY (graph, edge_attribute)
 BOOST_INSTALL_PROPERTY (graph, vertex_attribute)
 BOOST_INSTALL_PROPERTY (graph, graph_attribute)
 BOOST_INSTALL_PROPERTY (vertex, attribute)
 BOOST_INSTALL_PROPERTY (edge, attribute)
 BOOST_ITERATOR_FACADE_INTEROP (-, detail::choose_difference_type, return, distance_from) BOOST_ITERATOR_FACADE_PLUS((iterator_facade< Derived
 BOOST_LOW_BITS_MASK_SPECIALIZE (unsigned char)
 BOOST_TEMPLATED_STREAM (ostream, E, T)&operator<<(BOOST_TEMPLATED_STREAM(ostream
 BOOST_TT_AUX_BOOL_TRAIT_DEF1 (is_recursive_wrapper, T,(::boost::detail::is_recursive_wrapper_impl< T >::value)) template< typename T > struct unwrap_recursive
 BOOST_TT_AUX_BOOL_TRAIT_DEF1 (is_lvalue_iterator, T,::boost::detail::is_readable_lvalue_iterator_impl< T >::value) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_non_const_lvalue_iterator
template<typename Visitor, typename Visitable1, typename Visitable2>
 BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE (typename Visitor::result_type) apply_visitor(const Visitor &visitor
template<typename Graph, typename CentralityMap, typename EdgeCentralityMap>
void brandes_betweenness_centrality (const Graph &g, CentralityMap centrality, EdgeCentralityMap edge_centrality_map)
template<typename Graph, typename CentralityMap>
void brandes_betweenness_centrality (const Graph &g, CentralityMap centrality)
template<typename Graph, typename Param, typename Tag, typename Rest>
void brandes_betweenness_centrality (const Graph &g, const bgl_named_params< Param, Tag, Rest > &params)
template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, typename IncomingMap, typename DistanceMap, typename DependencyMap, typename PathCountMap, typename VertexIndexMap, typename WeightMap>
void brandes_betweenness_centrality (const Graph &g, CentralityMap centrality, EdgeCentralityMap edge_centrality_map, IncomingMap incoming, DistanceMap distance, DependencyMap dependency, PathCountMap path_count, VertexIndexMap vertex_index, WeightMap weight_map)
template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, typename IncomingMap, typename DistanceMap, typename DependencyMap, typename PathCountMap, typename VertexIndexMap>
void brandes_betweenness_centrality (const Graph &g, CentralityMap centrality, EdgeCentralityMap edge_centrality_map, IncomingMap incoming, DistanceMap distance, DependencyMap dependency, PathCountMap path_count, VertexIndexMap vertex_index)
template<class VertexListGraph, class P, class T, class R>
void breadth_first_search (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, const bgl_named_params< P, T, R > &params)
template<class VertexListGraph, class Buffer, class BFSVisitor, class ColorMap>
void breadth_first_search (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, Buffer &Q, BFSVisitor vis, ColorMap color)
template<class IncidenceGraph, class P, class T, class R>
void breadth_first_visit (const IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor s, const bgl_named_params< P, T, R > &params)
template<class IncidenceGraph, class Buffer, class BFSVisitor, class ColorMap>
void breadth_first_visit (const IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor s, Buffer &Q, BFSVisitor vis, ColorMap color)
template<typename Buffer>
bgl_named_params
< detail::wrap_ref< Buffer >
, buffer_param_t > 
buffer (Buffer &b)
template<typename Graph, typename ComponentMap, typename ComponentLists>
void build_component_lists (const Graph &g, typename graph_traits< Graph >::vertices_size_type num_scc, ComponentMap component_number, ComponentLists &components)
void BuildFileList (std::list< std::string > *pl, const char *files, bool recurse)
cache_t & cache ()
void BOOST_THREAD_DECL call_once (void(*func)(), once_flag &flag)
template<typename CapacityMap>
bgl_named_params< CapacityMap,
edge_capacity_t > 
capacity_map (CapacityMap pmap)
template<class Generator>
int catch_exceptions (Generator function_object, std::ostream &out, std::ostream &err)
template<typename Graph, typename CentralityMap>
property_traits< CentralityMap >
::value_type 
central_point_dominance (const Graph &g, CentralityMap centrality)
template<typename CentralityMap>
bgl_named_params
< CentralityMap,
vertex_centrality_t > 
centrality_map (const CentralityMap &r)
template<class T>
void checked_array_delete (T *x)
template<class T>
void checked_delete (T *x)
template<typename Param, typename Graph, typename PropertyTag>
detail::choose_pmap_helper
< Param, Graph, PropertyTag >
::const_result_type 
choose_const_pmap (const Param &p, const Graph &g, PropertyTag tag)
template<class P, class Default>
const
detail::choose_param_helper< P >
::template result< Default >
::type & 
choose_param (const P &param, const Default &d)
template<typename Param, typename Graph, typename PropertyTag>
detail::choose_pmap_helper
< Param, Graph, PropertyTag >
::result_type 
choose_pmap (const Param &p, Graph &g, PropertyTag tag)
template<typename VertexListGraph, typename PositionMap, typename Radius>
void circle_graph_layout (const VertexListGraph &g, PositionMap position, Radius radius)
 Layout the graph with the vertices at the points of a regular n-polygon.
template<class Config>
void clear_in_edges (typename Config::vertex_descriptor u, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
void clear_out_edges (typename Config::vertex_descriptor u, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
void clear_out_edges (typename Config::vertex_descriptor u, directed_graph_helper< Config > &g_)
template<class EdgeList, class Allocator>
void clear_vertex (typename EdgeList::value_type u, std::vector< EdgeList, Allocator > &g)
template<typename G>
void clear_vertex (typename subgraph< G >::vertex_descriptor v_local, subgraph< G > &g)
template<class vtype, class etype>
void clear_vertex (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, leda::GRAPH< vtype, etype > &g)
template<class Config>
void clear_vertex (typename Config::vertex_descriptor u, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
void clear_vertex (typename Config::vertex_descriptor u, undirected_graph_helper< Config > &g_)
template<class Config>
void clear_vertex (typename Config::vertex_descriptor u, directed_graph_helper< Config > &g_)
template<typename VP, typename EP, typename GP, typename A>
void clear_vertex (typename adjacency_matrix< undirectedS, VP, EP, GP, A >::vertex_descriptor u, adjacency_matrix< undirectedS, VP, EP, GP, A > &g)
template<typename VP, typename EP, typename GP, typename A>
void clear_vertex (typename adjacency_matrix< directedS, VP, EP, GP, A >::vertex_descriptor u, adjacency_matrix< directedS, VP, EP, GP, A > &g)
template<typename ColorMap>
bgl_named_params< ColorMap,
vertex_color_t > 
color_map (ColorMap pmap)
template<class ParentIterator>
boost::detail::iterator_traits
< ParentIterator >
::difference_type 
component_count (ParentIterator first, ParentIterator last)
template<class ParentIterator>
void compress_components (ParentIterator first, ParentIterator last)
template<class Graph, class ComponentMap>
property_traits< ComponentMap >
::value_type 
connected_components (const Graph &g, ComponentMap c)
template<class Graph, class ComponentMap, class P, class T, class R>
property_traits< ComponentMap >
::value_type 
connected_components (const Graph &g, ComponentMap c, const bgl_named_params< P, T, R > &params)
template<typename Vertex, typename Graph>
connects_predicate< Vertex, Graph > connects (Vertex u, Vertex v, const Graph &g)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_iterator< T >
::type 
const_begin (const T &r)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_iterator< T >
::type 
const_end (const T &r)
template<class Iterator, class ConstIterator>
void const_nonconst_iterator_test (Iterator i, ConstIterator j)
template<class T, class U>
shared_ptr< T > const_pointer_cast (shared_ptr< U > const &r)
template<class T, class U>
intrusive_ptr< T > const_pointer_cast (intrusive_ptr< U > const &p)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_reverse_iterator
< T >::type 
const_rbegin (const T &r)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_reverse_iterator
< T >::type 
const_rend (const T &r)
template<class Iterator, class T>
void constant_lvalue_iterator_test (Iterator i, T v1)
template<typename Container, typename T>
bool contains (const Container &c, const T &value)
template<typename InputIterator, typename T>
bool contains (InputIterator first, InputIterator last, T value)
void * convert_type (void *const p, class_id src_t, class_id dst_t, bool polymorphic)
template<typename Container, typename OutIter>
OutIter copy (const Container &c, OutIter result)
template<typename IncidenceGraph, typename MutableGraph>
graph_traits< MutableGraph >
::vertex_descriptor 
copy_component (IncidenceGraph &g_in, typename graph_traits< IncidenceGraph >::vertex_descriptor src, MutableGraph &g_out)
template<typename IncidenceGraph, typename MutableGraph, typename P, typename T, typename R>
graph_traits< MutableGraph >
::vertex_descriptor 
copy_component (IncidenceGraph &g_in, typename graph_traits< IncidenceGraph >::vertex_descriptor src, MutableGraph &g_out, const bgl_named_params< P, T, R > &params)
template<typename VertexListGraph, typename MutableGraph, class P, class T, class R>
void copy_graph (const VertexListGraph &g_in, MutableGraph &g_out, const bgl_named_params< P, T, R > &params)
template<typename VertexListGraph, typename MutableGraph>
void copy_graph (const VertexListGraph &g_in, MutableGraph &g_out)
template<class InputIter, class Size, class OutputIter>
OutputIter copy_n (InputIter first, Size count, OutputIter result)
template<typename SeqT, typename Range>
SeqT copy_range (const Range &r)
 copy a range into a sequence
template<typename Container, typename T>
std::size_t count (const Container &c, const T &value)
template<typename Container, typename Predicate>
std::size_t count_if (const Container &c, Predicate p)
template<std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem>
uint_t< Bits >::fast crc (void const *buffer, std::size_t byte_count BOOST_CRC_DUMMY_PARM_TYPE)
template<typename Graph, typename ComponentLists, typename ComponentNumberMap, typename CondensationGraph>
void create_condensation_graph (const Graph &g, const ComponentLists &components, ComponentNumberMap component_number, CondensationGraph &cg)
template<typename Graph, typename ComponentLists, typename ComponentNumberMap, typename CondensationGraph, typename EdgeMultiplicityMap>
void create_condensation_graph (const Graph &g, const ComponentLists &components, ComponentNumberMap component_number, CondensationGraph &cg, EdgeMultiplicityMap edge_mult_map)
template<class T>
reference_wrapper< T const >
BOOST_REF_CONST 
cref (T const &t)
template<class Graph, class OutputIterator, class Color, class Degree>
OutputIterator cuthill_mckee_ordering (Graph &G, OutputIterator inverse_permutation, Color color, Degree degree)
template<class Graph, class OutputIterator, class ColorMap, class DegreeMap>
OutputIterator cuthill_mckee_ordering (Graph &g, typename graph_traits< Graph >::vertex_descriptor s, OutputIterator inverse_permutation, ColorMap color, DegreeMap degree)
template<class VertexListGraph, class Param, class Tag, class Rest>
void dag_shortest_paths (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, const bgl_named_params< Param, Tag, Rest > &params)
template<class VertexListGraph, class DijkstraVisitor, class DistanceMap, class WeightMap, class ColorMap, class PredecessorMap, class Compare, class Combine, class DistInf, class DistZero>
void dag_shortest_paths (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, DistanceMap distance, WeightMap weight, ColorMap color, PredecessorMap pred, DijkstraVisitor vis, Compare compare, Combine combine, DistInf inf, DistZero zero)
template<typename G>
graph_traits< G >::degree_size_type degree (typename graph_traits< G >::vertex_descriptor u_local, const subgraph< G > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::degree_size_type 
degree (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &)
template<class Config>
Config::degree_size_type degree (typename Config::vertex_descriptor u, const bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
Config::degree_size_type degree (typename Config::vertex_descriptor u, const undirected_graph_helper< Config > &g_)
type_index_t::iterator demand_type (class_id type)
type_index_iterator_pair demand_types (class_id t1, class_id t2)
template<class VertexListGraph, class P, class T, class R>
void depth_first_search (const VertexListGraph &g, const bgl_named_params< P, T, R > &params)
template<class VertexListGraph, class DFSVisitor, class ColorMap>
void depth_first_search (const VertexListGraph &g, DFSVisitor vis, ColorMap color)
template<class VertexListGraph, class DFSVisitor, class ColorMap>
void depth_first_search (const VertexListGraph &g, DFSVisitor vis, ColorMap color, typename graph_traits< VertexListGraph >::vertex_descriptor start_vertex)
template<class IncidenceGraph, class DFSVisitor, class ColorMap, class TerminatorFunc>
void depth_first_visit (const IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor u, DFSVisitor vis, ColorMap color, TerminatorFunc func=TerminatorFunc())
template<class IncidenceGraph, class DFSVisitor, class ColorMap>
void depth_first_visit (const IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor u, DFSVisitor vis, ColorMap color)
template<class VertexListGraph, class Param, class Tag, class Rest>
void dijkstra_shortest_paths (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, const bgl_named_params< Param, Tag, Rest > &params)
template<class VertexListGraph, class DijkstraVisitor, class PredecessorMap, class DistanceMap, class WeightMap, class IndexMap, class Compare, class Combine, class DistInf, class DistZero>
void dijkstra_shortest_paths (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, PredecessorMap predecessor, DistanceMap distance, WeightMap weight, IndexMap index_map, Compare compare, Combine combine, DistInf inf, DistZero zero, DijkstraVisitor vis)
template<class VertexListGraph, class DijkstraVisitor, class PredecessorMap, class DistanceMap, class WeightMap, class IndexMap, class Compare, class Combine, class DistZero>
void dijkstra_shortest_paths_no_init (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, PredecessorMap predecessor, DistanceMap distance, WeightMap weight, IndexMap index_map, Compare compare, Combine combine, DistZero zero, DijkstraVisitor vis)
template<typename DiscoverTimeMap>
bgl_named_params
< DiscoverTimeMap,
vertex_discover_time_t > 
discover_time_map (DiscoverTimeMap pmap)
template<typename Combine>
bgl_named_params< Combine,
distance_combine_t > 
distance_combine (Combine cmb)
template<typename Compare>
bgl_named_params< Compare,
distance_compare_t > 
distance_compare (Compare cmp)
template<typename Init>
bgl_named_params< Init,
distance_inf_t > 
distance_inf (Init init)
template<typename DistanceMap>
bgl_named_params< DistanceMap,
vertex_distance_t > 
distance_map (DistanceMap pmap)
template<typename Init>
bgl_named_params< Init,
distance_zero_t > 
distance_zero (Init init)
template<class TreeNode, class Compare, class ExternalData>
TreeNode down_heap (TreeNode x, const Compare &comp, ExternalData &edata)
template<typename B, typename A, typename stringT>
void dump_to_string (const dynamic_bitset< B, A > &b, stringT &s)
template<class T, class U>
shared_ptr< T > dynamic_pointer_cast (shared_ptr< U > const &r)
template<class T, class U>
intrusive_ptr< T > dynamic_pointer_cast (intrusive_ptr< U > const &p)
template<class EdgeList, class Allocator>
std::pair< typename
detail::val_edge< EdgeList >
::type, bool > 
edge (typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector< EdgeList, Allocator > &g)
template<typename G>
std::pair< typename subgraph
< G >::edge_descriptor, bool > 
edge (typename subgraph< G >::vertex_descriptor u_local, typename subgraph< G >::vertex_descriptor v_local, const subgraph< G > &g)
template<class BidirectionalGraph, class GRef>
std::pair< typename
BidirectionalGraph::edge_descriptor,
bool > 
edge (const typename BidirectionalGraph::vertex_descriptor u, const typename BidirectionalGraph::vertex_descriptor v, const reverse_graph< BidirectionalGraph, GRef > &g)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::edge_descriptor, bool > 
edge (typename filtered_graph< G, EP, VP >::vertex_descriptor u, typename filtered_graph< G, EP, VP >::vertex_descriptor v, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
std::pair< typename
Config::edge_descriptor, bool > 
edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const adj_list_helper< Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::edge_descriptor, bool > 
edge (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor v, const adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename EdgeCentralityMap>
bgl_named_params
< EdgeCentralityMap,
edge_centrality_t > 
edge_centrality_map (const EdgeCentralityMap &r)
template<class VertexListGraph, class OutputIterator>
graph_traits< VertexListGraph >
::degree_size_type 
edge_connectivity (VertexListGraph &g, OutputIterator disconnecting_set)
template<typename Copier>
bgl_named_params< Copier,
edge_copy_t > 
edge_copy (const Copier &c)
template<typename T>
detail::graph::edge_or_side
< true, T > 
edge_length (T x)
 States that the given quantity is an edge length.
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::out_edge_iterator, typename
filtered_graph< G, EP, VP >
::out_edge_iterator > 
edge_range (typename filtered_graph< G, EP, VP >::vertex_descriptor u, typename filtered_graph< G, EP, VP >::vertex_descriptor v, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
std::pair< typename
Config::out_edge_iterator,
typename
Config::out_edge_iterator > 
edge_range (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const adj_list_helper< Config, Base > &g_)
template<typename G>
std::pair< typename subgraph
< G >::edge_iterator, typename
subgraph< G >::edge_iterator > 
edges (const subgraph< G > &g)
template<class BidirectionalGraph, class GRef>
std::pair< typename
reverse_graph
< BidirectionalGraph >
::edge_iterator, typename
reverse_graph
< BidirectionalGraph >
::edge_iterator > 
edges (const reverse_graph< BidirectionalGraph, GRef > &g)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::edge_iterator, typename
filtered_graph< G, EP, VP >
::edge_iterator > 
edges (const filtered_graph< G, EP, VP > &g)
template<class G, class EI, class T, class D>
std::pair< typename
edge_list_impl_ra< G, EI, T, D >
::edge_iterator, typename
edge_list_impl_ra< G, EI, T, D >
::edge_iterator > 
edges (const edge_list_impl_ra< G, EI, T, D > &g_)
template<class G, class EI, class T, class D>
std::pair< typename
edge_list_impl< G, EI, T, D >
::edge_iterator, typename
edge_list_impl< G, EI, T, D >
::edge_iterator > 
edges (const edge_list_impl< G, EI, T, D > &g_)
template<class Config>
std::pair< typename
Config::edge_iterator,
typename Config::edge_iterator > 
edges (const bidirectional_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_iterator,
typename Config::edge_iterator > 
edges (const undirected_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
Config::edge_iterator,
typename Config::edge_iterator > 
edges (const directed_edges_helper< Config > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::edge_iterator,
typename adjacency_matrix< D,
VP, EP, GP, A >::edge_iterator > 
edges (const adjacency_matrix< D, VP, EP, GP, A > &g_)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
edgesum (const Graph &g, VertexIndexMap index_map)
template<class Graph>
property_traits< typename
property_map< Graph,
edge_capacity_t >::const_type >
::value_type 
edmunds_karp_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink)
template<class Graph, class P, class T, class R>
detail::edge_capacity_value
< Graph, P, T, R >::type 
edmunds_karp_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink, const bgl_named_params< P, T, R > &params)
template<class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap, class ColorMap, class PredEdgeMap>
property_traits
< CapacityEdgeMap >
::value_type 
edmunds_karp_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink, CapacityEdgeMap cap, ResidualCapacityEdgeMap res, ReverseEdgeMap rev, ColorMap color, PredEdgeMap pred)
template<class Iterator>
bool empty (const iterator_range< Iterator > &r)
template<class T>
bool empty (const T &r)
template<typename C>
bool empty (const C &c)
template<class T>
BOOST_DEDUCED_TYPENAME
range_const_iterator< T >
::type 
end (const T &r)
template<class T>
BOOST_DEDUCED_TYPENAME
range_iterator< T >::type 
end (T &r)
template<typename C>
BOOST_DEDUCED_TYPENAME
range_result_iterator< C >
::type 
end (C &c)
template<typename T>
std::vector< T >::const_iterator end (const std::vector< T > &c)
template<typename T>
std::vector< T >::iterator end (std::vector< T > &c)
template<typename Iter1, typename Iter2>
Iter2 end (const std::pair< Iter1, Iter2 > &p)
template<typename Container1, typename Container2>
bool equal (const Container1 &c1, const Container2 &c2)
template<class OptionalPointee>
bool equal_pointees (OptionalPointee const &x, OptionalPointee const &y)
template<class Graph, class Vertex, class Color, class Degree>
Vertex find_starting_node (Graph &G, Vertex r, Color color, Degree degree)
template<typename ForwardIter, class BinaryPredicate>
ForwardIter first_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
ForwardIter first_max_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
ForwardIter first_min_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
ForwardIter first_min_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
std::pair< ForwardIter,
ForwardIter > 
first_min_first_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
std::pair< ForwardIter,
ForwardIter > 
first_min_first_max_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
std::pair< ForwardIter,
ForwardIter > 
first_min_last_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
std::pair< ForwardIter,
ForwardIter > 
first_min_last_max_element (ForwardIter first, ForwardIter last)
template<class Iterator, class T>
void forward_iterator_test (Iterator i, T v1, T v2)
template<class Iterator, class T>
void forward_readable_iterator_test (Iterator i, Iterator j, T val1, T val2)
template<class Iterator, class T>
void forward_swappable_iterator_test (Iterator i, Iterator j, T val1, T val2)
BOOST_PROGRAM_OPTIONS_DECL
std::wstring 
from_8_bit (const std::string &s, const std::codecvt< wchar_t, char, std::mbstate_t > &cvt)
template<typename BlockIterator, typename B, typename A>
void from_block_range (BlockIterator first, BlockIterator last, dynamic_bitset< B, A > &result)
BOOST_PROGRAM_OPTIONS_DECL
std::wstring 
from_local_8_bit (const std::string &s)
BOOST_PROGRAM_OPTIONS_DECL
std::wstring 
from_utf8 (const std::string &s)
smart_graph & full_graph ()
template<typename F, typename G>
bool function_equal (const F &f, const G &g)
template<class Concept>
void function_requires (mpl::identity< Concept > *=0)
template<typename IntType>
IntType gcd (IntType n, IntType m)
template<typename MutableGraph, typename RandNumGen, typename VertexOutputIterator, typename EdgeOutputIterator>
void generate_random_graph (MutableGraph &g, typename graph_traits< MutableGraph >::vertices_size_type V, typename graph_traits< MutableGraph >::vertices_size_type E, RandNumGen &gen, VertexOutputIterator vertex_out, EdgeOutputIterator edge_out, bool self_edges=false)
template<typename MutableGraph, class RandNumGen>
void generate_random_graph (MutableGraph &g, typename graph_traits< MutableGraph >::vertices_size_type V, typename graph_traits< MutableGraph >::vertices_size_type E, RandNumGen &gen, bool allow_parallel=true, bool self_edges=false)
template<typename MutableGraph, class RandNumGen>
void generate_random_graph1 (MutableGraph &g, typename graph_traits< MutableGraph >::vertices_size_type V, typename graph_traits< MutableGraph >::vertices_size_type E, RandNumGen &gen, bool allow_parallel=true, bool self_edges=false)
template<typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
add_reference< const U >::type get (const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > &operand)
template<typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
add_reference< U >::type get (boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > &operand)
template<typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
add_pointer< const U >::type get (const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > *operand)
template<typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
add_pointer< U >::type get (boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > *operand)
template<class T>
T & get (value_initialized< T > &x)
template<class T>
T const & get (value_initialized< T > const &x)
template<class PropertyMap, class Reference, class K>
Reference get (const put_get_helper< Reference, PropertyMap > &pa, const K &k)
template<typename K, typename V>
const
readable_property_map_archetype
< K, V >::reference & 
get (const readable_property_map_archetype< K, V > &, const typename readable_property_map_archetype< K, V >::key_type &)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >::pointer_type 
get (optional< T > *opt)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >
::pointer_const_type 
get (optional< T > const *opt)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >::reference_type 
get (optional< T > &opt)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >
::reference_const_type 
get (optional< T > const &opt)
template<typename G, typename Property, typename Key>
property_traits< typename
property_map< subgraph< G >
, Property >::const_type >
::value_type 
get (Property, const subgraph< G > &g, const Key &k)
template<typename G, typename Property>
property_map< subgraph< G >
, Property >::const_type 
get (Property, const subgraph< G > &g)
template<typename G, typename Property>
property_map< subgraph< G >
, Property >::type 
get (Property, subgraph< G > &g)
long get (edge_length_t, const sgb_const_graph_ptr &, const sgb_edge &key)
long get (edge_length_t, const sgb_graph_ptr &, const sgb_edge &key)
sgb_edge_length_map< long & > get (edge_length_t, sgb_graph_ptr &)
sgb_edge_length_map< const long & > get (edge_length_t, const sgb_const_graph_ptr &)
sgb_edge_length_map< const long & > get (edge_length_t, const sgb_graph_ptr &)
sgb_vertex_name_map get (vertex_name_t, sgb_graph_ptr)
sgb_vertex_id_map get (vertex_index_t, sgb_graph_ptr g)
template<class BidirectionalGraph, class GRef, class Property, class Key>
property_traits< typename
property_map
< BidirectionalGraph, Property >
::const_type >::value_type 
get (Property p, const reverse_graph< BidirectionalGraph, GRef > &g, const Key &k)
template<class BidirGraph, class GRef, class Property>
property_map< BidirGraph,
Property >::const_type 
get (Property p, const reverse_graph< BidirGraph, GRef > &g)
template<class BidirGraph, class GRef, class Property>
property_map< BidirGraph,
Property >::type 
get (Property p, reverse_graph< BidirGraph, GRef > &g)
template<class vtype, class etype, class PropertyTag, class Key>
boost::property_traits
< typename boost::property_map
< leda::GRAPH< vtype, etype >
, PropertyTag >::const_type >
::value_type 
get (PropertyTag p, const leda::GRAPH< vtype, etype > &g, const Key &key)
template<class vtype, class etype>
property_map< leda::GRAPH
< vtype, etype >, edge_all_t >
::const_type 
get (edge_all_t, const leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
property_map< leda::GRAPH
< vtype, etype >, edge_all_t >
::type 
get (edge_all_t, leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
property_map< leda::GRAPH
< vtype, etype >, vertex_all_t >
::const_type 
get (vertex_all_t, const leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
property_map< leda::GRAPH
< vtype, etype >, vertex_all_t >
::type 
get (vertex_all_t, leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
leda_graph_id_map get (edge_index_t, const leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
leda_graph_id_map get (vertex_index_t, const leda::GRAPH< vtype, etype > &g)
template<typename Graph, typename P, typename N, typename C, typename Property, typename Key>
property_traits< typename
property_map< Graph, Property >
::const_type >::value_type 
get (Property p, const graph_as_tree< Graph, P, N, C > &g, const Key &k)
template<typename Graph, typename P, typename N, typename C, typename Property>
property_map< Graph, Property >
::const_type 
get (Property p, const graph_as_tree< Graph, P, N, C > &g)
template<typename Graph, typename P, typename N, typename C, typename Property>
property_map< Graph, Property >
::type 
get (Property p, graph_as_tree< Graph, P, N, C > &g)
template<typename G, typename P, typename K, typename V>
property_traits< typename
property_map
< property_graph_archetype< G,
P, V >, P >::const_type >
::value_type 
get (P p, const property_graph_archetype< G, P, V > &g, K k)
template<typename G, typename P, typename V>
property_map
< property_graph_archetype< G,
P, V >, P >::const_type 
get (P, const property_graph_archetype< G, P, V > &)
template<typename G, typename P, typename V>
property_map
< property_graph_archetype< G,
P, V >, P >::type 
get (P, property_graph_archetype< G, P, V > &)
template<typename G, typename EP, typename VP, typename Property, typename Key>
property_map_value< G,
Property >::type 
get (Property p, const filtered_graph< G, EP, VP > &g, const Key &k)
template<typename G, typename EP, typename VP, typename Property>
property_map< G, Property >
::const_type 
get (Property p, const filtered_graph< G, EP, VP > &g)
template<typename G, typename EP, typename VP, typename Property>
property_map< G, Property >::type get (Property p, filtered_graph< G, EP, VP > &g)
template<class G, class EI, class T, class D>
get (edge_index_t, const edge_list_impl_ra< G, EI, T, D > &, typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e)
template<class G, class EI, class T, class D>
property_map
< edge_list_impl_ra< G, EI, T,
D >, edge_index_t >::type 
get (edge_index_t, const edge_list_impl_ra< G, EI, T, D > &)
template<class G, class EI, class T, class D>
get (edge_index_t, const edge_list_impl< G, EI, T, D > &, typename edge_list_impl< G, EI, T, D >::edge_descriptor e)
template<class G, class EI, class T, class D>
property_map< edge_list_impl
< G, EI, T, D >, edge_index_t >
::type 
get (edge_index_t, const edge_list_impl< G, EI, T, D > &)
template<class Config, class Base, class Property, class Key>
boost::property_traits
< typename boost::property_map
< typename Config::graph_type,
Property >::const_type >
::value_type 
get (Property p, const adj_list_helper< Config, Base > &g, const Key &key)
template<class Config, class Base, class Property>
boost::property_map< typename
Config::graph_type, Property >
::const_type 
get (Property p, const adj_list_helper< Config, Base > &g)
template<class Config, class Base, class Property>
boost::property_map< typename
Config::graph_type, Property >
::type 
get (Property p, adj_list_helper< Config, Base > &g)
template<class Tag, class Vertex, class EdgeVec, class Property>
const property_value< Property,
Tag >::type & 
get (Tag property_tag, const detail::stored_ra_edge_iter< Vertex, EdgeVec, Property > &e)
template<class Tag, class Vertex, class Iter, class Property>
const property_value< Property,
Tag >::type & 
get (Tag property_tag, const detail::stored_edge_iter< Vertex, Iter, Property > &e)
template<class Tag, class Vertex, class Property>
const property_value< Property,
Tag >::type & 
get (Tag property_tag, const detail::stored_edge_property< Vertex, Property > &e)
template<typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename Allocator, typename T, typename Bundle, typename Key>
get (T Bundle::*p, adjacency_matrix< Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator > const &g, const Key &key)
template<typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename Allocator, typename T, typename Bundle>
property_map< adjacency_matrix
< Directed, VertexProperty,
EdgeProperty, GraphProperty,
Allocator >, T Bundle::* >
::const_type 
get (T Bundle::*p, adjacency_matrix< Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator > const &g)
template<typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename Allocator, typename T, typename Bundle>
property_map< adjacency_matrix
< Directed, VertexProperty,
EdgeProperty, GraphProperty,
Allocator >, T Bundle::* >
::type 
get (T Bundle::*p, adjacency_matrix< Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator > &g)
template<typename Property, typename D, typename VP, typename EP, typename GP, typename A, typename Key>
property_traits< typename
property_map< adjacency_matrix
< D, VP, EP, GP, A >, Property >
::const_type >::value_type 
get (Property p, const adjacency_matrix< D, VP, EP, GP, A > &g, const Key &key)
template<typename Property, typename D, typename VP, typename EP, typename GP, typename A>
property_map< adjacency_matrix
< D, VP, EP, GP, A >, Property >
::const_type 
get (Property p, const adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename Property, typename D, typename VP, typename EP, typename GP, typename A>
property_map< adjacency_matrix
< D, VP, EP, GP, A >, Property >
::type 
get (Property p, adjacency_matrix< D, VP, EP, GP, A > &g)
template<class Value, class Next, class V, class Stag>
void get (property< Stag, Value, Next > &p, const V &v, Stag)
template<class Tag, class Value, class Next, class V, class Stag>
void get (property< Tag, Value, Next > &p, const V &v, Stag s)
template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle, typename Key>
get (T Bundle::*p, adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > const &g, const Key &key)
template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle>
property_map< adjacency_list
< OutEdgeListS, VertexListS,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty,
EdgeListS >, T Bundle::* >
::const_type 
get (T Bundle::*p, adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > const &g)
template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle>
property_map< adjacency_list
< OutEdgeListS, VertexListS,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty,
EdgeListS >, T Bundle::* >
::type 
get (T Bundle::*p, adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > &g)
template<class D, class T>
D * get_deleter (shared_ptr< T > const &p)
template<class Tag1, class Tag2, class T1, class Base>
property_value
< bgl_named_params< T1, Tag1,
Base >, Tag2 >::type 
get_param (const bgl_named_params< T1, Tag1, Base > &p, Tag2 tag2)
template<class T>
T * get_pointer (scoped_ptr< T > const &p)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >::pointer_type 
get_pointer (optional< T > &opt)
template<class T>
BOOST_DEDUCED_TYPENAME
optional< T >
::pointer_const_type 
get_pointer (optional< T > const &opt)
template<class T>
T * get_pointer (intrusive_ptr< T > const &p)
template<class T>
T * get_pointer (std::auto_ptr< T > const &p)
template<class T>
T * get_pointer (T *p)
template<class T>
T * get_pointer (shared_ptr< T > const &p)
template<typename G, typename Tag>
const graph_property< G, Tag >
::type & 
get_property (const subgraph< G > &g, Tag tag)
template<typename G, typename Tag>
graph_property< G, Tag >::type & get_property (subgraph< G > &g, Tag tag)
template<class OEL, class VL, class DS, class VP, class EP, class GP, class Tag, class EL>
const graph_property
< adjacency_list< OEL, VL, DS,
VP, EP, GP, EL >, Tag >::type & 
get_property (const adjacency_list< OEL, VL, DS, VP, EP, GP, EL > &g, Tag)
template<class OEL, class VL, class DS, class VP, class EP, class GP, class Tag, class EL>
graph_property< adjacency_list
< OEL, VL, DS, VP, EP, GP, EL >
, Tag >::type & 
get_property (adjacency_list< OEL, VL, DS, VP, EP, GP, EL > &g, Tag)
template<class Graph, class Tag>
graph_property_iter_range
< Graph, Tag >::const_type 
get_property_iter_range (const Graph &graph, const Tag &tag)
template<class Graph, class Tag>
graph_property_iter_range
< Graph, Tag >::type 
get_property_iter_range (Graph &graph, const Tag &tag)
template<class Tag>
sgb_edge_util_map< Tag,
typename Tag::type & > 
get_property_map (Tag, sgb_graph_ptr &g, edge_property_tag)
template<class Tag>
sgb_edge_util_map< Tag, const
typename Tag::type & > 
get_property_map (Tag, const sgb_graph_ptr &g, edge_property_tag)
template<class Tag>
sgb_vertex_util_map< Tag,
typename Tag::type & > 
get_property_map (Tag, sgb_graph_ptr &g, vertex_property_tag)
template<class Tag>
sgb_vertex_util_map< Tag,
const typename Tag::type & > 
get_property_map (Tag, const sgb_graph_ptr &g, vertex_property_tag)
template<class Tag1, class Tag2, class T1, class Base>
const property_value< property
< Tag1, T1, Base >, Tag2 >
::type & 
get_property_value (const property< Tag1, T1, Base > &p, Tag2 tag2)
template<class Tag1, class Tag2, class T1, class Base>
property_value< property< Tag1,
T1, Base >, Tag2 >::type & 
get_property_value (property< Tag1, T1, Base > &p, Tag2 tag2)
template<class Triangle, class Line>
void get_sharing (const Triangle &a, const Triangle &b, Line &l)
long & get_util (util &u, long)
char *& get_util (util &u, char *)
sgb_graph_ptr & get_util (util &u, sgb_graph_ptr)
Arc *& get_util (util &u, Arc *)
Vertex *& get_util (util &u, Vertex *)
void getSubset (no_property &p, const no_property &s)
template<class Tag, class Value, class Next, class Stag, class Svalue>
void getSubset (property< Tag, Value, Next > &p, const property< Stag, Svalue, no_property > &s)
template<class Tag, class Value, class Next, class Stag, class Svalue, class Snext>
void getSubset (property< Tag, Value, Next > &p, const property< Stag, Svalue, Snext > &s)
default_color_type gray (default_color_type)
default_color_type green (default_color_type)
void * identity_cast (void *p)
template<class T>
void ignore_unused_variable_warning (const T &)
template<typename T>
implicit_cast (typename mpl::identity< T >::type x)
template<typename G>
graph_traits< G >::degree_size_type in_degree (typename graph_traits< G >::vertex_descriptor u_local, const subgraph< G > &g)
template<class BidirectionalGraph, class GRef>
BidirectionalGraph::degree_size_type in_degree (const typename BidirectionalGraph::vertex_descriptor u, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::degree_size_type 
in_degree (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &)
template<typename G, typename EP, typename VP>
filtered_graph< G, EP, VP >
::degree_size_type 
in_degree (typename filtered_graph< G, EP, VP >::vertex_descriptor u, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
Config::degree_size_type in_degree (typename Config::vertex_descriptor u, const adj_list_helper< Config, Base > &g_)
template<class G, class C, class B>
const C::InEdgeList & in_edge_list (const vec_adj_list_impl< G, C, B > &g, typename C::vertex_descriptor v)
template<class G, class C, class B>
C::InEdgeList & in_edge_list (vec_adj_list_impl< G, C, B > &g, typename C::vertex_descriptor v)
template<class C>
const C::InEdgeList & in_edge_list (const bidirectional_graph_helper< C > &, typename C::vertex_descriptor v)
template<class C>
C::InEdgeList & in_edge_list (bidirectional_graph_helper< C > &, typename C::vertex_descriptor v)
template<class C>
const C::InEdgeList & in_edge_list (const undirected_graph_helper< C > &, typename C::vertex_descriptor v)
template<class C>
C::InEdgeList & in_edge_list (undirected_graph_helper< C > &, typename C::vertex_descriptor v)
template<class Graph, class Vertex>
bool in_edge_set (Graph &g, Vertex u, Vertex v)
template<class Graph, class Edge>
bool in_edge_set (Graph &g, Edge e)
template<typename G>
std::pair< typename
graph_traits< G >
::in_edge_iterator, typename
graph_traits< G >
::in_edge_iterator > 
in_edges (typename graph_traits< G >::vertex_descriptor u_local, const subgraph< G > &g)
template<class BidirectionalGraph, class GRef>
std::pair< typename
BidirectionalGraph::out_edge_iterator,
typename
BidirectionalGraph::out_edge_iterator > 
in_edges (const typename BidirectionalGraph::vertex_descriptor u, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::in_edge_iterator, typename
graph_traits< leda::GRAPH
< vtype, etype >
>::in_edge_iterator > 
in_edges (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &g)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::in_edge_iterator, typename
filtered_graph< G, EP, VP >
::in_edge_iterator > 
in_edges (typename filtered_graph< G, EP, VP >::vertex_descriptor u, const filtered_graph< G, EP, VP > &g)
template<class Config>
std::pair< typename
Config::in_edge_iterator,
typename
Config::in_edge_iterator > 
in_edges (typename Config::vertex_descriptor u, const bidirectional_graph_helper< Config > &g_)
template<class Config>
std::pair< typename
Config::in_edge_iterator,
typename
Config::in_edge_iterator > 
in_edges (typename Config::vertex_descriptor u, const undirected_graph_helper< Config > &g_)
template<class Graph, class Vertex>
bool in_vertex_set (Graph &g, Vertex v)
template<class UndirectedGraph>
std::pair< typename
graph_traits< UndirectedGraph >
::vertex_descriptor, typename
graph_traits< UndirectedGraph >
::vertex_descriptor > 
incident (typename graph_traits< UndirectedGraph >::edge_descriptor e, UndirectedGraph &g)
template<class Graph>
std::pair< typename
graph_traits< Graph >
::out_edge_iterator, typename
graph_traits< Graph >
::out_edge_iterator > 
incident_edges (typename graph_traits< Graph >::vertex_descriptor u, Graph &g)
template<typename Vertex, typename Graph>
incident_from_predicate
< Vertex, Graph > 
incident_from (Vertex u, const Graph &g)
template<typename Vertex, typename Graph>
incident_on_predicate< Vertex,
Graph > 
incident_on (Vertex u, const Graph &g)
template<typename Vertex, typename Graph>
incident_to_predicate< Vertex,
Graph > 
incident_to (Vertex u, const Graph &g)
template<class EdgeListGraph, class DisjointSets>
void incremental_components (EdgeListGraph &g, DisjointSets &ds)
template<class VertexListGraph, class DisjointSets>
void initialize_incremental_components (VertexListGraph &G, DisjointSets &ds)
template<class Iterator, class T>
void input_iterator_test (Iterator i, T v1, T v2)
template<typename T>
int integer_log2 (T x)
template<class Config, class Base>
std::pair< typename
Config::inv_adjacency_iterator,
typename
Config::inv_adjacency_iterator > 
inv_adjacent_vertices (typename Config::vertex_descriptor u, const adj_list_helper< Config, Base > &g_)
template<class PermIter>
void invert_permutation (PermIter X, PermIter Xend)
template<class Visitor, class T, class Graph, class Tag>
void invoke_visitors (Visitor &v, T x, Graph &g, Tag)
template<class Visitor, class Rest, class T, class Graph, class Tag>
void invoke_visitors (std::pair< Visitor, Rest > &vlist, T x, Graph &g, Tag tag)
template<typename Container, typename T>
void iota (Container &c, const T &value)
template<class ForwardIterator, class T>
void iota (ForwardIterator first, ForwardIterator last, T value)
template<class Graph, class Vertex>
bool is_adj_dispatch (Graph &g, Vertex a, Vertex b, undirected_tag)
template<class Graph, class Vertex>
bool is_adj_dispatch (Graph &g, Vertex a, Vertex b, directed_tag)
template<class Graph, class Vertex>
bool is_adj_dispatch (Graph &g, Vertex a, Vertex b, bidirectional_tag)
template<class Graph, class Vertex>
bool is_adjacent (Graph &g, Vertex a, Vertex b)
template<typename VertexListGraph, typename VertexColorMap>
bool is_connected (const VertexListGraph &g, VertexColorMap color)
bool is_default_param (const detail::error_property_not_found &)
template<typename T>
bool is_default_param (const T &)
template<typename ParentMap>
bool is_descendant (typename property_traits< ParentMap >::value_type x, typename property_traits< ParentMap >::value_type y, ParentMap parent)
template<typename Graph>
bool is_directed (const Graph &)
template<typename IncidenceGraph, typename VertexColorMap>
bool is_reachable (typename graph_traits< IncidenceGraph >::vertex_descriptor x, typename graph_traits< IncidenceGraph >::vertex_descriptor y, const IncidenceGraph &g, VertexColorMap color)
template<typename Graph>
bool is_self_loop (typename graph_traits< Graph >::edge_descriptor e, const Graph &g)
template<typename Container, typename StrictWeakOrdering>
bool is_sorted (const Container &c, StrictWeakOrdering comp)
template<typename Container>
bool is_sorted (const Container &c)
template<typename ForwardIterator, typename StrictWeakOrdering>
bool is_sorted (ForwardIterator first, ForwardIterator last, StrictWeakOrdering comp)
template<typename ForwardIterator>
bool is_sorted (ForwardIterator first, ForwardIterator last)
template<typename Graph>
bool is_undirected (const Graph &g)
template<typename Graph1, typename Graph2>
bool isomorphism (const Graph1 &g1, const Graph2 &g2)
template<typename Graph1, typename Graph2, class P, class T, class R>
bool isomorphism (const Graph1 &g1, const Graph2 &g2, const bgl_named_params< P, T, R > &params)
template<typename Graph1, typename Graph2, typename IsoMapping, typename Invariant1, typename Invariant2, typename IndexMap1, typename IndexMap2>
bool isomorphism (const Graph1 &G1, const Graph2 &G2, IsoMapping f, Invariant1 invariant1, Invariant2 invariant2, std::size_t max_invariant, IndexMap1 index_map1, IndexMap2 index_map2)
template<typename IsoMap>
bgl_named_params< IsoMap,
vertex_isomorphism_t > 
isomorphism_map (const IsoMap &c)
template<typename Graph>
graph_traits< Graph >
::vertices_size_type 
ith_bandwidth (typename graph_traits< Graph >::vertex_descriptor i, const Graph &g)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
ith_bandwidth (typename graph_traits< Graph >::vertex_descriptor i, const Graph &g, VertexIndexMap index)
template<typename Graph>
graph_traits< Graph >
::vertices_size_type 
ith_wavefront (typename graph_traits< Graph >::vertex_descriptor i, const Graph &g)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
ith_wavefront (typename graph_traits< Graph >::vertex_descriptor i, const Graph &g, VertexIndexMap index)
template<class VertexAndEdgeListGraph, class DistanceMatrix>
bool johnson_all_pairs_shortest_paths (VertexAndEdgeListGraph &g, DistanceMatrix &D)
template<class VertexAndEdgeListGraph, class DistanceMatrix, class P, class T, class R>
bool johnson_all_pairs_shortest_paths (VertexAndEdgeListGraph &g, DistanceMatrix &D, const bgl_named_params< P, T, R > &params)
template<class VertexAndEdgeListGraph, class DistanceMatrix, class VertexID, class Weight, class DistanceZero>
bool johnson_all_pairs_shortest_paths (VertexAndEdgeListGraph &g1, DistanceMatrix &D, VertexID id1, Weight w1, DistanceZero zero)
template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength>
bool kamada_kawai_spring_layout (const Graph &g, PositionMap position, WeightMap weight, detail::graph::edge_or_side< EdgeOrSideLength, T > edge_or_side_length)
template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength, typename Done>
bool kamada_kawai_spring_layout (const Graph &g, PositionMap position, WeightMap weight, detail::graph::edge_or_side< EdgeOrSideLength, T > edge_or_side_length, Done done)
template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength, typename Done>
bool kamada_kawai_spring_layout (const Graph &g, PositionMap position, WeightMap weight, detail::graph::edge_or_side< EdgeOrSideLength, T > edge_or_side_length, Done done, typename property_traits< WeightMap >::value_type spring_constant)
template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength, typename Done, typename VertexIndexMap>
bool kamada_kawai_spring_layout (const Graph &g, PositionMap position, WeightMap weight, detail::graph::edge_or_side< EdgeOrSideLength, T > edge_or_side_length, Done done, typename property_traits< WeightMap >::value_type spring_constant, VertexIndexMap index)
template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength, typename Done, typename VertexIndexMap, typename DistanceMatrix, typename SpringStrengthMatrix, typename PartialDerivativeMap>
bool kamada_kawai_spring_layout (const Graph &g, PositionMap position, WeightMap weight, detail::graph::edge_or_side< EdgeOrSideLength, T > edge_or_side_length, Done done, typename property_traits< WeightMap >::value_type spring_constant, VertexIndexMap index, DistanceMatrix distance, SpringStrengthMatrix spring_strength, PartialDerivativeMap partial_derivatives)
 Kamada-Kawai spring layout for undirected graphs.
template<class Graph, class DFSVisitor, class ComponentsMap, class DiscoverTime, class FinishTime, class ColorMap>
property_traits< ComponentsMap >
::value_type 
kosaraju_strong_components (Graph &G, ComponentsMap c, FinishTime finish_time, ColorMap color)
template<class Graph, class OutputIterator, class P, class T, class R>
void kruskal_minimum_spanning_tree (const Graph &g, OutputIterator spanning_tree_edges, const bgl_named_params< P, T, R > &params)
template<class Graph, class OutputIterator>
void kruskal_minimum_spanning_tree (const Graph &g, OutputIterator spanning_tree_edges)
template<typename ForwardIter, class BinaryPredicate>
ForwardIter last_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
ForwardIter last_max_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
ForwardIter last_min_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
ForwardIter last_min_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
std::pair< ForwardIter,
ForwardIter > 
last_min_first_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
std::pair< ForwardIter,
ForwardIter > 
last_min_first_max_element (ForwardIter first, ForwardIter last)
template<typename ForwardIter, class BinaryPredicate>
std::pair< ForwardIter,
ForwardIter > 
last_min_last_max_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
std::pair< ForwardIter,
ForwardIter > 
last_min_last_max_element (ForwardIter first, ForwardIter last)
template<typename IntType>
IntType lcm (IntType n, IntType m)
template<class OptionalPointee>
bool less_pointees (OptionalPointee const &x, OptionalPointee const &y)
template<typename Target, typename Source>
Target lexical_cast (Source arg)
template<class Archive, class T>
void load (Archive &ar, boost::scoped_ptr< T > &t, const unsigned int)
template<class Archive, class T>
void load (Archive &ar, boost::optional< T > &t, const unsigned int)
template<typename T>
int lowest_bit (T x)
template<class R, class F>
_bi::af0< R, F > make_adaptable (F f)
template<class UniquePairAssociativeContainer>
const_associative_property_map
< UniquePairAssociativeContainer > 
make_assoc_property_map (const UniquePairAssociativeContainer &c)
template<class UniquePairAssociativeContainer>
associative_property_map
< UniquePairAssociativeContainer > 
make_assoc_property_map (UniquePairAssociativeContainer &c)
template<class Visitors>
bellman_visitor< Visitors > make_bellman_visitor (Visitors vis)
template<class Visitors>
bfs_visitor< Visitors > make_bfs_visitor (Visitors vis)
template<class RandomAccessContainer>
iterator_property_map
< typename
RandomAccessContainer::iterator,
identity_property_map,
typename
RandomAccessContainer::value_type,
typename
RandomAccessContainer::reference > 
make_container_vertex_map (RandomAccessContainer &c)
template<class PropertyGraph, class RandomAccessContainer>
iterator_property_map
< typename
RandomAccessContainer::iterator,
typename property_map
< PropertyGraph,
vertex_index_t >::type,
typename
RandomAccessContainer::value_type,
typename
RandomAccessContainer::reference > 
make_container_vertex_map (RandomAccessContainer &c, const PropertyGraph &g)
template<class Incrementable>
counting_iterator< Incrementable > make_counting_iterator (Incrementable x)
template<typename Graph>
degree_property_map< Graph > make_degree_map (const Graph &g)
template<class Visitors>
dfs_visitor< Visitors > make_dfs_visitor (Visitors vis)
template<class Visitors>
dijkstra_visitor< Visitors > make_dijkstra_visitor (Visitors vis)
template<typename Graph>
attributes_writer< typename
property_map< Graph,
edge_attribute_t >::const_type > 
make_edge_attributes_writer (const Graph &g)
template<class EdgeIter>
edge_list< EdgeIter > make_edge_list (EdgeIter first, EdgeIter last)
template<class Predicate, class Iterator>
filter_iterator< Predicate,
Iterator > 
make_filter_iterator (typename iterators::enable_if< is_class< Predicate >, Iterator >::type x, Iterator end=Iterator())
template<class Predicate, class Iterator>
filter_iterator< Predicate,
Iterator > 
make_filter_iterator (Predicate f, Iterator x, Iterator end=Iterator())
template<typename Graph, typename EdgePredicate, typename VertexPredicate>
filtered_graph< Graph,
EdgePredicate, VertexPredicate > 
make_filtered_graph (Graph &g, EdgePredicate ep, VertexPredicate vp)
template<typename Graph, typename EdgePredicate>
filtered_graph< Graph,
EdgePredicate > 
make_filtered_graph (Graph &g, EdgePredicate ep)
template<class UnaryFunction>
function_output_iterator
< UnaryFunction > 
make_function_output_iterator (const UnaryFunction &f=UnaryFunction())
template<class Generator>
generator_iterator< Generator > make_generator_iterator (Generator &gen)
template<typename Graph>
graph_attributes_writer
< typename graph_property
< Graph,
graph_graph_attribute_t >
::type, typename
graph_property< Graph,
graph_vertex_attribute_t >
::type, typename
graph_property< Graph,
graph_edge_attribute_t >::type > 
make_graph_attributes_writer (const Graph &g)
template<typename GAttrMap, typename NAttrMap, typename EAttrMap>
graph_attributes_writer
< GAttrMap, NAttrMap, EAttrMap > 
make_graph_attributes_writer (const GAttrMap &g_attr, const NAttrMap &n_attr, const EAttrMap &e_attr)
template<typename Compare, typename ReadablePropertyMap>
indirect_cmp
< ReadablePropertyMap, Compare > 
make_indirect_cmp (const Compare &cmp, ReadablePropertyMap pmap)
template<class Traits, class Iter>
indirect_iterator< Iter, Traits > make_indirect_iterator (Iter x, Traits *=0)
template<class Iter>
indirect_iterator< Iter > make_indirect_iterator (Iter x)
template<typename ReadablePropertyMap>
indirect_pmap
< ReadablePropertyMap > 
make_indirect_pmap (ReadablePropertyMap pmap)
template<class IntegerType>
integer_range< IntegerType > make_integer_range (IntegerType first, IntegerType last)
template<class RAIter, class Value, class ID>
iterator_property_map< RAIter,
ID, Value, Value & > 
make_iterator_property_map (RAIter iter, ID id, Value)
template<class RAIter, class ID>
iterator_property_map< RAIter,
ID, typename
std::iterator_traits< RAIter >
::value_type, typename
std::iterator_traits< RAIter >
::reference > 
make_iterator_property_map (RAIter iter, ID id)
template<class ForwardRange>
iterator_range
< BOOST_DEDUCED_TYPENAME
range_const_iterator
< ForwardRange >::type > 
make_iterator_range (const ForwardRange &r)
template<class ForwardRange>
iterator_range
< BOOST_DEDUCED_TYPENAME
range_iterator< ForwardRange >
::type > 
make_iterator_range (ForwardRange &r)
 iterator_range construct helper
template<typename IteratorT>
iterator_range< IteratorT > make_iterator_range (IteratorT Begin, IteratorT End)
 iterator_range construct helper
template<class RandomAccessIterator>
iterator_property_map
< RandomAccessIterator,
identity_property_map,
typename std::iterator_traits
< RandomAccessIterator >
::value_type, typename
std::iterator_traits
< RandomAccessIterator >
::reference > 
make_iterator_vertex_map (RandomAccessIterator iter)
template<class PropertyGraph, class RandomAccessIterator>
iterator_property_map
< RandomAccessIterator,
typename property_map
< PropertyGraph,
vertex_index_t >::type,
typename std::iterator_traits
< RandomAccessIterator >
::value_type, typename
std::iterator_traits
< RandomAccessIterator >
::reference > 
make_iterator_vertex_map (RandomAccessIterator iter, const PropertyGraph &g)
template<class Name>
label_writer< Name > make_label_writer (Name n)
template<class E>
leda_node_property_map< E, E
&, leda_node_map< E > * > 
make_leda_node_property_map (leda_node_map< E > &a)
template<class E>
leda_node_property_map< E,
const E &, const leda_node_map
< E > * > 
make_leda_node_property_map (const leda_node_map< E > &a)
template<class E>
leda_node_property_map< E, E
&, leda_node_array< E > * > 
make_leda_node_property_map (leda_node_array< E > &a)
template<class E>
leda_node_property_map< E,
const E &, const
leda_node_array< E > * > 
make_leda_node_property_map (const leda_node_array< E > &a)
template<class T1, class T2, class T3, class T4, class T5>
std::pair< T1, std::pair< T2,
std::pair< T3, std::pair< T4,
T5 > > > > 
make_list (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
template<class T1, class T2, class T3, class T4>
std::pair< T1, std::pair< T2,
std::pair< T3, T4 > > > 
make_list (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
template<class T1, class T2, class T3>
std::pair< T1, std::pair< T2,
T3 > > 
make_list (const T1 &t1, const T2 &t2, const T3 &t3)
template<class T1, class T2>
std::pair< T1, T2 > make_list (const T1 &t1, const T2 &t2)
template<class Visitors>
neighbor_bfs_visitor< Visitors > make_neighbor_bfs_visitor (Visitors vis)
template<class ElementIterator, class IndexIterator>
permutation_iterator
< ElementIterator,
IndexIterator > 
make_permutation_iterator (ElementIterator e, IndexIterator i)
template<class T>
pfto_wrapper< T > make_pfto_wrapper (const pfto_wrapper< T > &t, int)
template<class T>
pfto_wrapper< T > make_pfto_wrapper (const T &t, BOOST_PFTO int)
template<class PropertyMap, class Iterator>
property_map_iterator_generator
< PropertyMap, Iterator >
::type 
make_property_map_iterator (PropertyMap pmap, Iterator iter)
template<class BidirectionalGraph>
reverse_graph
< BidirectionalGraph,
BidirectionalGraph & > 
make_reverse_graph (BidirectionalGraph &g)
template<class BidirectionalGraph>
reverse_graph< BidirectionalGraph > make_reverse_graph (const BidirectionalGraph &g)
template<class BidirectionalIterator>
reverse_iterator
< BidirectionalIterator > 
make_reverse_iterator (BidirectionalIterator x)
template<class RAIter, class Value, class ID>
safe_iterator_property_map
< RAIter, ID, Value, Value & > 
make_safe_iterator_property_map (RAIter iter, std::size_t n, ID id, Value)
template<class RAIter, class ID>
safe_iterator_property_map
< RAIter, ID, typename
boost::detail::iterator_traits
< RAIter >::value_type,
typename
boost::detail::iterator_traits
< RAIter >::reference > 
make_safe_iterator_property_map (RAIter iter, std::size_t n, ID id)
template<class IterA, class IterB>
shadow_iterator_generator
< IterA, IterB >::type 
make_shadow_iter (IterA a, IterB b)
template<class T>
shared_ptr< T > make_shared (weak_ptr< T > const &r)
template<typename Container>
shared_container_iterator
< Container > 
make_shared_container_iterator (typename Container::iterator iter, boost::shared_ptr< Container > const &container)
template<typename Container>
std::pair
< shared_container_iterator
< Container >
, shared_container_iterator
< Container > > 
make_shared_container_range (boost::shared_ptr< Container > const &container)
template<class Type, class Iterator, class TokenizerFunc>
token_iterator_generator
< TokenizerFunc, Iterator,
Type >::type 
make_token_iterator (Iterator begin, Iterator end, const TokenizerFunc &fun)
template<class UnaryFunction, class Iterator>
iterators::enable_if< is_class
< UnaryFunction >
, transform_iterator
< UnaryFunction, Iterator >
>::type 
make_transform_iterator (Iterator it)
template<class UnaryFunction, class Iterator>
transform_iterator
< UnaryFunction, Iterator > 
make_transform_iterator (Iterator it, UnaryFunction fun)
template<typename T, typename IndexMap>
vector_property_map< T, IndexMap > make_vector_property_map (IndexMap index)
template<typename Graph>
attributes_writer< typename
property_map< Graph,
vertex_attribute_t >
::const_type > 
make_vertex_attributes_writer (const Graph &g)
template<typename Graph, typename Set>
vertex_subset_compliment_filter
< Graph, Set >::type 
make_vertex_subset_compliment_filter (Graph &g, const Set &s)
template<typename Graph, typename Set>
vertex_subset_filter< Graph,
Set >::type 
make_vertex_subset_filter (Graph &g, const Set &s)
template<typename IteratorTuple>
zip_iterator< IteratorTuple > make_zip_iterator (IteratorTuple t)
template<typename Graph>
graph_traits< Graph >
::vertices_size_type 
max_wavefront (const Graph &g)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
max_wavefront (const Graph &g, VertexIndexMap index)
template<class R, class T>
_mfi::dm< R, T > mem_fn (R T::*f)
template<class S, class T, class A>
mem_fun1_t< S, T, A > mem_fun (S(T::*f)(A))
template<class S, class T>
mem_fun_t< S, T > mem_fun (S(T::*f)())
template<class S, class T, class A>
mem_fun1_ref_t< S, T, A > mem_fun_ref (S(T::*f)(A))
template<class S, class T>
mem_fun_ref_t< S, T > mem_fun_ref (S(T::*f)())
template<typename Iter, typename Compare>
void merge_sort (Iter first, Iter last, Compare cmp)
template<typename Graph>
std::pair< typename
graph_traits< Graph >
::vertex_descriptor, typename
graph_traits< Graph >
::degree_size_type > 
min_degree_vertex (Graph &g)
template<class Graph, class DegreeMap, class InversePermutationMap, class PermutationMap, class SuperNodeMap, class VertexIndexMap>
void minimum_degree_ordering (Graph &G, DegreeMap degree, InversePermutationMap inverse_perm, PermutationMap perm, SuperNodeMap supernode_size, int delta, VertexIndexMap vertex_index_map)
template<typename T, class BinaryPredicate>
tuple< T const &, T const & > minmax (T const &a, T const &b, BinaryPredicate comp)
template<typename T>
tuple< T const &, T const & > minmax (T const &a, T const &b)
template<typename ForwardIter, class BinaryPredicate>
std::pair< ForwardIter,
ForwardIter > 
minmax_element (ForwardIter first, ForwardIter last, BinaryPredicate comp)
template<typename ForwardIter>
std::pair< ForwardIter,
ForwardIter > 
minmax_element (ForwardIter first, ForwardIter last)
template<class Iterator, class T>
void mutable_trivial_iterator_test (const Iterator i, const Iterator j, T val)
template<class VertexListGraph, class P, class T, class R>
void neighbor_breadth_first_search (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, const bgl_named_params< P, T, R > &params)
template<class IncidenceGraph, class P, class T, class R>
void neighbor_breadth_first_visit (IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor s, const bgl_named_params< P, T, R > &params)
template<typename Graph, typename VertexIterator, typename OutputIterator>
void neighbors (const Graph &g, VertexIterator first, VertexIterator last, OutputIterator result)
template<typename Graph, typename OutputIterator>
void neighbors (const Graph &g, typename graph_traits< Graph >::vertex_descriptor u, OutputIterator result)
template<class T, class Distance>
next (T x, Distance n)
template<class T>
next (T x)
template<class Iterator, class T>
void non_const_lvalue_iterator_test (Iterator i, T v1, T v2)
template<typename Container, typename Predicate>
bool none (const Container &c, Predicate p)
template<typename InputIterator, typename Predicate>
bool none (InputIterator first, InputIterator last, Predicate p)
template<class ParentIterator>
void normalize_components (ParentIterator first, ParentIterator last)
template<class Predicate>
unary_negate< Predicate > not1 (Predicate &pred)
template<class Predicate>
unary_negate< Predicate > not1 (const Predicate &pred)
template<class Predicate>
binary_negate< Predicate > not2 (Predicate &pred)
template<class Predicate>
binary_negate< Predicate > not2 (const Predicate &pred)
template<typename G>
subgraph< G >::edges_size_type num_edges (const subgraph< G > &g)
long num_edges (sgb_const_graph_ptr g)
template<class BidirectionalGraph, class GRef>
reverse_graph
< BidirectionalGraph >
::edges_size_type 
num_edges (const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::edges_size_type 
num_edges (const leda::GRAPH< vtype, etype > &g)
template<typename G, typename EP, typename VP>
filtered_graph< G, EP, VP >
::edges_size_type 
num_edges (const filtered_graph< G, EP, VP > &g)
template<class EdgeIter, class T, class D, class Cat>
std::size_t num_edges (const edge_list< EdgeIter, T, D, Cat > &el)
template<class Config>
Config::edges_size_type num_edges (const bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
Config::edges_size_type num_edges (const undirected_graph_helper< Config > &g_)
template<class Config>
Config::edges_size_type num_edges (const directed_graph_helper< Config > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::edges_size_type 
num_edges (const adjacency_matrix< D, VP, EP, GP, A > &g)
template<class EdgeList, class Alloc>
std::vector< EdgeList, Alloc >
::size_type 
num_vertices (const std::vector< EdgeList, Alloc > &v)
template<typename G>
subgraph< G >::vertices_size_type num_vertices (const subgraph< G > &g)
long num_vertices (sgb_const_graph_ptr g)
template<class BidirectionalGraph, class GRef>
BidirectionalGraph::vertices_size_type num_vertices (const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::vertices_size_type 
num_vertices (const leda::GRAPH< vtype, etype > &g)
template<typename V, typename D, typename P, typename B>
vertex_list_graph_archetype< V,
D, P, B >::vertices_size_type 
num_vertices (const vertex_list_graph_archetype< V, D, P, B > &)
template<typename G, typename EP, typename VP>
filtered_graph< G, EP, VP >
::vertices_size_type 
num_vertices (const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
Config::vertices_size_type num_vertices (const adj_list_helper< Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::vertices_size_type 
num_vertices (const adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename Target, typename Source>
Target numeric_cast (Source arg BOOST_EXPLICIT_DEFAULT_TARGET)
template<class T>
numeric_limits_max (T)
template<typename Block, typename Allocator>
dynamic_bitset< Block, Allocator > operator & (const dynamic_bitset< Block, Allocator > &b1, const dynamic_bitset< Block, Allocator > &b2)
bool operator!= (const spoiler1 &, const spoiler1 &)
template<class T>
bool operator!= (shared_array< T > const &a, shared_array< T > const &b)
template<class RandomAccessIterator>
bool operator!= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator!= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator!= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator!= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator!= (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator!= (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class ForwardRange, class ForwardRange2>
bool operator!= (const sub_range< ForwardRange > &l, const sub_range< ForwardRange2 > &r)
template<class IteratorT, class ForwardRange>
bool operator!= (const iterator_range< IteratorT > &l, const ForwardRange &r)
template<class Iterator1T, class Iterator2T>
bool operator!= (const iterator_range< Iterator1T > &l, const iterator_range< Iterator2T > &r)
template<class IteratorT, class ForwardRange>
bool operator!= (const ForwardRange &l, const iterator_range< IteratorT > &r)
template<class _Tp, class _Sequence>
bool operator!= (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class T>
bool operator!= (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator!= (optional< T > const &x, detail::none_t const &y)
template<class T>
bool operator!= (optional< T > const &x, optional< T > const &y)
template<class T>
bool operator!= (T *a, intrusive_ptr< T > const &b)
template<class T>
bool operator!= (intrusive_ptr< T > const &a, T *b)
template<class T, class U>
bool operator!= (intrusive_ptr< T > const &a, intrusive_ptr< U > const &b)
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS, typename Allocator>
void operator!= (const BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &, const BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &)
template<typename Functor>
 operator!= (reference_wrapper< Functor > g, const function_base &f)
template<typename Functor>
 operator!= (const function_base &f, reference_wrapper< Functor > g)
template<typename Functor>
 operator!= (Functor g, const function_base &f)
template<typename Functor>
 operator!= (const function_base &f, Functor g)
bool operator!= (detail::function::useless_clear_type *, const function_base &f)
bool operator!= (const function_base &f, detail::function::useless_clear_type *)
template<typename Block, typename Allocator>
bool operator!= (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class T, class U>
bool operator!= (shared_ptr< T > const &a, shared_ptr< U > const &b)
template<class T, class U>
bool operator!= (shared_array< T > const &a, shared_array< U > const &b)
template<class Base1, class Base2>
boolean_archetype operator!= (const equality_comparable2_first_archetype< Base1 > &, const equality_comparable2_second_archetype< Base2 > &)
template<class Base>
boolean_archetype operator!= (const equality_comparable_archetype< Base > &, const equality_comparable_archetype< Base > &)
template<class T, std::size_t N>
bool operator!= (const array< T, N > &x, const array< T, N > &y)
inner_prod::RetMult operator* (const inner_prod::Tin1 &, const inner_prod::Tin2 &)
spoiler1 operator+ (const spoiler1 &, const spoiler1 &)
inner_prod::RetAdd operator+ (const inner_prod::T &, const inner_prod::RetMult &)
template<class RandomAccessIterator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type > 
operator+ (const sub_match< RandomAccessIterator > &m1, const sub_match< RandomAccessIterator > &m2)
template<class RandomAccessIterator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type > 
operator+ (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type > 
operator+ (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type > 
operator+ (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type > 
operator+ (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator, class traits, class Allocator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type, traits,
Allocator > 
operator+ (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
std::basic_string< typename
re_detail::regex_iterator_traits
< RandomAccessIterator >
::value_type, traits,
Allocator > 
operator+ (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<typename IntType>
rational< IntType > operator+ (const rational< IntType > &r)
template<class IntT>
int_iterator< IntT > operator+ (IntT n, int_iterator< IntT > t)
template<class T>
mutable_random_access_iterator_archetype
< T > 
operator+ (typename mutable_random_access_iterator_archetype< T >::difference_type, const mutable_random_access_iterator_archetype< T > &x)
template<class T>
random_access_iterator_archetype
< T > 
operator+ (typename random_access_iterator_archetype< T >::difference_type, const random_access_iterator_archetype< T > &x)
template<class I, class V, class TC, class R, class D>
detail::postfix_increment_result
< I, V, R, TC >::type 
operator++ (iterator_facade< I, V, TC, R, D > &i, int)
template<typename IntType>
rational< IntType > operator- (const rational< IntType > &r)
template<typename Block, typename Allocator>
dynamic_bitset< Block, Allocator > operator- (const dynamic_bitset< Block, Allocator > &b1, const dynamic_bitset< Block, Allocator > &b2)
template<class T, class U>
bool operator< (weak_ptr< T > const &a, weak_ptr< U > const &b)
template<class T, class U>
bool operator< (shared_ptr< T > const &a, shared_ptr< U > const &b)
template<class RandomAccessIterator>
bool operator< (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator< (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator< (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator< (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator< (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator< (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class ForwardRange, class ForwardRange2>
bool operator< (const sub_range< ForwardRange > &l, const sub_range< ForwardRange2 > &r)
template<class IteratorT, class ForwardRange>
bool operator< (const iterator_range< IteratorT > &l, const ForwardRange &r)
template<class Iterator1T, class Iterator2T>
bool operator< (const iterator_range< Iterator1T > &l, const iterator_range< Iterator2T > &r)
template<class IteratorT, class ForwardRange>
bool operator< (const ForwardRange &l, const iterator_range< IteratorT > &r)
template<class _Tp, class _Sequence>
bool operator< (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class _Tp, class _Seq>
bool operator< (const queue< _Tp, _Seq > &, const queue< _Tp, _Seq > &)
template<class T>
bool operator< (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator< (optional< T > const &x, detail::none_t const &)
template<class T>
bool operator< (optional< T > const &x, optional< T > const &y)
template<class T>
bool operator< (intrusive_ptr< T > const &a, intrusive_ptr< T > const &b)
template<typename Block, typename Allocator>
bool operator< (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class T>
bool operator< (shared_ptr< T > const &a, shared_ptr< T > const &b)
template<class T>
bool operator< (shared_array< T > const &a, shared_array< T > const &b)
template<class Base>
boolean_archetype operator< (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class Base>
boolean_archetype operator< (const less_than_comparable_archetype< Base > &, const less_than_comparable_archetype< Base > &)
bool operator< (const blank &, const blank &)
template<class T, std::size_t N>
bool operator< (const array< T, N > &x, const array< T, N > &y)
template<typename CharT>
basic_wrap_stringstream< CharT > & operator<< (basic_wrap_stringstream< CharT > &targ, basic_wrap_stringstream< CharT > &src)
template<typename CharT, typename T>
basic_wrap_stringstream< CharT > & operator<< (basic_wrap_stringstream< CharT > &targ, T const &t)
template<class E, class T, class Y>
std::basic_ostream< E, T > & operator<< (std::basic_ostream< E, T > &os, shared_ptr< Y > const &p)
template<class charT, class traits, class RandomAccessIterator>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &os, const sub_match< RandomAccessIterator > &s)
template<class charT, class traits, class BidiIterator, class Allocator>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &os, const match_results< BidiIterator, Allocator > &s)
template<class charT, class traits, class traits2, class Allocator>
std::basic_ostream< charT,
traits > & 
operator<< (std::basic_ostream< charT, traits > &os, const reg_expression< charT, traits2, Allocator > &e)
template<typename IntType>
std::ostream & operator<< (std::ostream &os, const rational< IntType > &r)
template<typename IteratorT, typename Elem, typename Traits>
std::basic_ostream< Elem,
Traits > & 
operator<< (std::basic_ostream< Elem, Traits > &Os, const iterator_range< IteratorT > &r)
 iterator_range output operator
template<class E, class T, class Y>
std::basic_ostream< E, T > & operator<< (std::basic_ostream< E, T > &os, intrusive_ptr< Y > const &p)
template<class Graph, class VP, class EP>
std::ostream & operator<< (std::ostream &out, const GraphPrinter< Graph, VP, EP > &gp)
 output stream for writing a graph
template<class Ch, class Tr, class Alloc>
std::basic_ostream< Ch, Tr > & operator<< (std::basic_ostream< Ch, Tr > &os, const basic_format< Ch, Tr, Alloc > &f)
template<typename Ch, typename Tr, typename Block, typename Alloc>
std::basic_ostream< Ch, Tr > & operator<< (std::basic_ostream< Ch, Tr > &os, const dynamic_bitset< Block, Alloc > &b)
template<typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_ostream< CharT,
Traits > & 
operator<< (std::basic_ostream< CharT, Traits > &os, const dynamic_bitset< Block, Allocator > &b)
template<class RandomAccessIterator>
bool operator<= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator<= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator<= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator<= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator<= (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator<= (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class _Tp, class _Sequence>
bool operator<= (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class T>
bool operator<= (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator<= (optional< T > const &x, detail::none_t const &y)
template<class T>
bool operator<= (optional< T > const &x, optional< T > const &y)
template<typename Block, typename Allocator>
bool operator<= (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class Base>
boolean_archetype operator<= (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class T, std::size_t N>
bool operator<= (const array< T, N > &x, const array< T, N > &y)
template<class T>
bool operator== (shared_array< T > const &a, shared_array< T > const &b)
template<class RandomAccessIterator>
bool operator== (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator== (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator== (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator== (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator== (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator== (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class ForwardRange, class ForwardRange2>
bool operator== (const sub_range< ForwardRange > &l, const sub_range< ForwardRange2 > &r)
template<class IteratorT, class ForwardRange>
bool operator== (const iterator_range< IteratorT > &l, const ForwardRange &r)
template<class Iterator1T, class Iterator2T>
bool operator== (const iterator_range< Iterator1T > &l, const iterator_range< Iterator2T > &r)
template<class IteratorT, class ForwardRange>
bool operator== (const ForwardRange &l, const iterator_range< IteratorT > &r)
template<class _Tp, class _Sequence>
bool operator== (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class _Tp, class _Seq>
bool operator== (const queue< _Tp, _Seq > &, const queue< _Tp, _Seq > &)
template<class T>
bool operator== (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator== (optional< T > const &x, detail::none_t const &)
template<class T>
bool operator== (optional< T > const &x, optional< T > const &y)
template<class T>
bool operator== (T *a, intrusive_ptr< T > const &b)
template<class T>
bool operator== (intrusive_ptr< T > const &a, T *b)
template<class T, class U>
bool operator== (intrusive_ptr< T > const &a, intrusive_ptr< U > const &b)
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS, typename Allocator>
void operator== (const BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &, const BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &)
template<typename Functor>
 operator== (reference_wrapper< Functor > g, const function_base &f)
template<typename Functor>
 operator== (const function_base &f, reference_wrapper< Functor > g)
template<typename Functor>
 operator== (Functor g, const function_base &f)
template<typename Functor>
 operator== (const function_base &f, Functor g)
bool operator== (detail::function::useless_clear_type *, const function_base &f)
bool operator== (const function_base &f, detail::function::useless_clear_type *)
template<typename Block, typename Allocator>
bool operator== (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class T, class U>
bool operator== (shared_ptr< T > const &a, shared_ptr< U > const &b)
template<class T, class U>
bool operator== (shared_array< T > const &a, shared_array< U > const &b)
template<class Base1, class Base2>
boolean_archetype operator== (const equality_comparable2_first_archetype< Base1 > &, const equality_comparable2_second_archetype< Base2 > &)
template<class Base>
boolean_archetype operator== (const equality_comparable_archetype< Base > &, const equality_comparable_archetype< Base > &)
bool operator== (const blank &, const blank &)
template<int I>
bool operator== (arg< I > const &, arg< I > const &)
template<class T, std::size_t N>
bool operator== (const array< T, N > &x, const array< T, N > &y)
template<class RandomAccessIterator>
bool operator> (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator> (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator> (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator> (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator> (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator> (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class _Tp, class _Sequence>
bool operator> (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class T>
bool operator> (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator> (optional< T > const &x, detail::none_t const &y)
template<class T>
bool operator> (optional< T > const &x, optional< T > const &y)
template<typename Block, typename Allocator>
bool operator> (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class Base>
boolean_archetype operator> (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class T, std::size_t N>
bool operator> (const array< T, N > &x, const array< T, N > &y)
template<class RandomAccessIterator>
bool operator>= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator>= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const &s)
template<class RandomAccessIterator>
bool operator>= (typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s, const sub_match< RandomAccessIterator > &m)
template<class RandomAccessIterator>
bool operator>= (const sub_match< RandomAccessIterator > &m, typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type const *s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator>= (const sub_match< RandomAccessIterator > &m, const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s)
template<class RandomAccessIterator, class traits, class Allocator>
bool operator>= (const std::basic_string< typename re_detail::regex_iterator_traits< RandomAccessIterator >::value_type, traits, Allocator > &s, const sub_match< RandomAccessIterator > &m)
template<class _Tp, class _Sequence>
bool operator>= (const queue< _Tp, _Sequence > &__x, const queue< _Tp, _Sequence > &__y)
template<class T>
bool operator>= (detail::none_t const &x, optional< T > const &y)
template<class T>
bool operator>= (optional< T > const &x, detail::none_t const &y)
template<class T>
bool operator>= (optional< T > const &x, optional< T > const &y)
template<typename Block, typename Allocator>
bool operator>= (const dynamic_bitset< Block, Allocator > &a, const dynamic_bitset< Block, Allocator > &b)
template<class Base>
boolean_archetype operator>= (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class T, std::size_t N>
bool operator>= (const array< T, N > &x, const array< T, N > &y)
template<typename IntType>
std::istream & operator>> (std::istream &is, rational< IntType > &r)
template<class Graph, class VP, class EP, class VPS, class EPS>
std::istream & operator>> (std::istream &in, GraphParser< Graph, VP, EP, VPS, EPS > gp)
 input stream for reading a graph
std::istream & operator>> (std::istream &in, no_property &)
template<class Tag, class Value>
std::istream & operator>> (std::istream &in, property< Tag, Value, no_property > &p)
template<class Tag, class Value, class Next>
std::istream & operator>> (std::istream &in, property< Tag, Value, Next > &p)
template<typename Ch, typename Tr, typename Block, typename Alloc>
std::basic_istream< Ch, Tr > & operator>> (std::basic_istream< Ch, Tr > &is, dynamic_bitset< Block, Alloc > &b)
template<typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_istream< CharT,
Traits > & 
operator>> (std::basic_istream< CharT, Traits > &is, dynamic_bitset< Block, Allocator > &b)
template<typename Block, typename Allocator>
dynamic_bitset< Block, Allocator > operator^ (const dynamic_bitset< Block, Allocator > &b1, const dynamic_bitset< Block, Allocator > &b2)
template<typename Block, typename Allocator>
dynamic_bitset< Block, Allocator > operator| (const dynamic_bitset< Block, Allocator > &b1, const dynamic_bitset< Block, Allocator > &b2)
template<class Graph>
graph_traits< Graph >
::vertex_descriptor 
opposite (typename graph_traits< Graph >::edge_descriptor e, typename graph_traits< Graph >::vertex_descriptor v, const Graph &g)
template<typename Orig2CopyMap>
bgl_named_params< Orig2CopyMap,
orig_to_copy_t > 
orig_to_copy (const Orig2CopyMap &c)
template<class EdgeList, class Alloc>
EdgeList::size_type out_degree (typename EdgeList::value_type v, const std::vector< EdgeList, Alloc > &g)
template<typename G>
graph_traits< G >::degree_size_type out_degree (typename graph_traits< G >::vertex_descriptor u_local, const subgraph< G > &g)
boost::graph_traits
< sgb_graph_ptr >
::degree_size_type 
out_degree (Vertex *u, sgb_const_graph_ptr g)
template<class BidirectionalGraph, class GRef>
BidirectionalGraph::degree_size_type out_degree (const typename BidirectionalGraph::vertex_descriptor u, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::degree_size_type 
out_degree (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &)
template<typename V, typename D, typename P, typename B>
vertex_list_graph_archetype< V,
D, P, B >::degree_size_type 
out_degree (const V &, const vertex_list_graph_archetype< V, D, P, B > &)
template<typename V, typename D, typename P, typename B>
adjacency_graph_archetype< V,
D, P, B >::degree_size_type 
out_degree (const V &, const adjacency_graph_archetype< V, D, P, B > &)
template<typename V, typename D, typename P, typename B>
incidence_graph_archetype< V,
D, P, B >::degree_size_type 
out_degree (const V &, const incidence_graph_archetype< V, D, P, B > &)
template<typename G, typename EP, typename VP>
filtered_graph< G, EP, VP >
::degree_size_type 
out_degree (typename filtered_graph< G, EP, VP >::vertex_descriptor u, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
Config::degree_size_type out_degree (typename Config::vertex_descriptor u, const adj_list_helper< Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::degree_size_type 
out_degree (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, const adjacency_matrix< D, VP, EP, GP, A > &g)
template<class EdgeList, class Alloc>
detail::val_out_edge_ret
< EdgeList >::type 
out_edges (typename EdgeList::value_type v, const std::vector< EdgeList, Alloc > &g)
template<typename G>
std::pair< typename
graph_traits< G >
::out_edge_iterator, typename
graph_traits< G >
::out_edge_iterator > 
out_edges (typename graph_traits< G >::vertex_descriptor u_local, const subgraph< G > &g)
std::pair
< sgb_out_edge_iterator,
sgb_out_edge_iterator > 
out_edges (Vertex *u, sgb_const_graph_ptr)
template<class BidirectionalGraph, class GRef>
std::pair< typename
BidirectionalGraph::in_edge_iterator,
typename
BidirectionalGraph::in_edge_iterator > 
out_edges (const typename BidirectionalGraph::vertex_descriptor u, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::out_edge_iterator,
typename graph_traits
< leda::GRAPH< vtype, etype >
>::out_edge_iterator > 
out_edges (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, const leda::GRAPH< vtype, etype > &g)
template<typename V, typename D, typename P, typename B>
std::pair< typename
incidence_graph_archetype< V,
D, P, B >::out_edge_iterator,
typename
incidence_graph_archetype< V,
D, P, B >::out_edge_iterator > 
out_edges (const V &, const incidence_graph_archetype< V, D, P, B > &)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::out_edge_iterator, typename
filtered_graph< G, EP, VP >
::out_edge_iterator > 
out_edges (typename filtered_graph< G, EP, VP >::vertex_descriptor u, const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
std::pair< typename
Config::out_edge_iterator,
typename
Config::out_edge_iterator > 
out_edges (typename Config::vertex_descriptor u, const adj_list_helper< Config, Base > &g_)
template<typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< undirectedS,
VP, EP, GP, A >
::out_edge_iterator, typename
adjacency_matrix< undirectedS,
VP, EP, GP, A >
::out_edge_iterator > 
out_edges (typename adjacency_matrix< undirectedS, VP, EP, GP, A >::vertex_descriptor u, const adjacency_matrix< undirectedS, VP, EP, GP, A > &g_)
template<typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< directedS,
VP, EP, GP, A >
::out_edge_iterator, typename
adjacency_matrix< directedS,
VP, EP, GP, A >
::out_edge_iterator > 
out_edges (typename adjacency_matrix< directedS, VP, EP, GP, A >::vertex_descriptor u, const adjacency_matrix< directedS, VP, EP, GP, A > &g_)
template<class RandIter, class RandIterPerm>
void permute (RandIter first, RandIter last, RandIterPerm p)
template<class InIter, class RandIterP, class RandIterR>
void permute_copy (InIter first, InIter last, RandIterP p, RandIterR result)
template<class Iter1, class Iter2>
void permute_serial (Iter1 permuter, Iter1 last, Iter2 result)
template<class Target, class Source>
Target polymorphic_cast (Source *x BOOST_EXPLICIT_DEFAULT_TARGET)
template<class Target, class Source>
Target polymorphic_downcast (Source *x BOOST_EXPLICIT_DEFAULT_TARGET)
bool pred1 (const match_results< ra_it > &)
template<typename PredecessorMap>
bgl_named_params
< PredecessorMap,
vertex_predecessor_t > 
predecessor_map (PredecessorMap pmap)
template<class VertexListGraph, class PredecessorMap>
void prim_minimum_spanning_tree (const VertexListGraph &g, PredecessorMap p_map)
template<class VertexListGraph, class PredecessorMap, class P, class T, class R>
void prim_minimum_spanning_tree (const VertexListGraph &g, PredecessorMap p_map, const bgl_named_params< P, T, R > &params)
template<class VertexListGraph, class DijkstraVisitor, class PredecessorMap, class DistanceMap, class WeightMap, class IndexMap>
void prim_minimum_spanning_tree (const VertexListGraph &g, typename graph_traits< VertexListGraph >::vertex_descriptor s, PredecessorMap predecessor, DistanceMap distance, WeightMap weight, IndexMap index_map, DijkstraVisitor vis)
template<class EdgeListGraph, class Name>
void print_edges (const EdgeListGraph &G, Name name)
template<class EdgeListGraph, class VertexName, class EdgeName>
void print_edges2 (const EdgeListGraph &G, VertexName vname, EdgeName ename)
template<class IncidenceGraph>
void print_graph (const IncidenceGraph &G)
template<class IncidenceGraph, class Name>
void print_graph (const IncidenceGraph &G, Name name)
template<class IncidenceGraph, class Name>
void print_graph_dispatch (const IncidenceGraph &G, Name name, undirected_tag)
template<class IncidenceGraph, class Name>
void print_graph_dispatch (const IncidenceGraph &G, Name name, directed_tag)
template<class IncidenceGraph, class Name>
void print_in_edges (const IncidenceGraph &G, Name name)
template<class VertexListGraph, class Name>
void print_vertices (const VertexListGraph &G, Name name)
template<class T, class Distance>
prior (T x, Distance n)
template<class T>
prior (T x)
template<typename Graph>
graph_traits< Graph >
::vertices_size_type 
profile (const Graph &g)
template<typename Graph, typename VertexIndexMap>
graph_traits< Graph >
::vertices_size_type 
profile (const Graph &g, VertexIndexMap index)
template<class F>
_bi::protected_bind_t< F > protect (F f)
template<class Graph, class Vertex, class ColorMap, class DegreeMap>
Vertex pseudo_peripheral_pair (Graph &G, const Vertex &u, int &ecc, ColorMap color, DegreeMap degree)
template<class Arg1, class Arg2, class Result>
pointer_to_binary_function
< Arg1, Arg2, Result > 
ptr_fun (Result(*f)(Arg1, Arg2))
template<class Arg, class Result>
pointer_to_unary_function< Arg,
Result > 
ptr_fun (Result(*f)(Arg))
template<class Graph>
property_traits< typename
property_map< Graph,
edge_capacity_t >::const_type >
::value_type 
push_relabel_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink)
template<class Graph, class P, class T, class R>
detail::edge_capacity_value
< Graph, P, T, R >::type 
push_relabel_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink, const bgl_named_params< P, T, R > &params)
template<class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap, class VertexIndexMap>
property_traits
< CapacityEdgeMap >
::value_type 
push_relabel_max_flow (Graph &g, typename graph_traits< Graph >::vertex_descriptor src, typename graph_traits< Graph >::vertex_descriptor sink, CapacityEdgeMap cap, ResidualCapacityEdgeMap res, ReverseEdgeMap rev, VertexIndexMap index_map)
template<class PropertyMap, class Reference, class K, class V>
void put (const put_get_helper< Reference, PropertyMap > &pa, K k, const V &v)
template<typename K, typename V>
void put (const writable_property_map_archetype< K, V > &, const typename writable_property_map_archetype< K, V >::key_type &, const typename writable_property_map_archetype< K, V >::value_type &)
template<typename G, typename Property, typename Key, typename Value>
void put (Property, subgraph< G > &g, const Key &k, const Value &val)
void put (edge_length_t, sgb_graph_ptr &, const sgb_edge &key, long value)
template<class BidirectionalGraph, class GRef, class Property, class Key, class Value>
void put (Property p, const reverse_graph< BidirectionalGraph, GRef > &g, const Key &k, const Value &val)
template<class vtype, class etype, class PropertyTag, class Key, class Value>
void put (PropertyTag p, leda::GRAPH< vtype, etype > &g, const Key &key, const Value &value)
template<typename Graph, typename P, typename N, typename C, typename Property, typename Key, typename Value>
void put (Property p, const graph_as_tree< Graph, P, N, C > &g, const Key &k, const Value &val)
template<typename G, typename P, typename V, typename Key>
void put (P p, property_graph_archetype< G, P, V > &g, const Key &key, const V &value)
template<typename G, typename EP, typename VP, typename Property, typename Key, typename Value>
void put (Property p, const filtered_graph< G, EP, VP > &g, const Key &k, const Value &val)
template<class Config, class Base, class Property, class Key, class Value>
void put (Property p, adj_list_helper< Config, Base > &g, const Key &key, const Value &value)
template<typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename Allocator, typename T, typename Bundle, typename Key>
void put (T Bundle::*p, adjacency_matrix< Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator > &g, const Key &key, const T &value)
template<typename Property, typename D, typename VP, typename EP, typename GP, typename A, typename Key, typename Value>
void put (Property p, adjacency_matrix< D, VP, EP, GP, A > &g, const Key &key, const Value &value)
template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty, typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle, typename Key>
void put (T Bundle::*p, adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > &g, const Key &key, const T &value)
template<class Iterator, class TrueVals>
void random_access_iterator_test (Iterator i, int N, TrueVals vals)
template<class Iterator, class TrueVals>
void random_access_readable_iterator_test (Iterator i, int N, TrueVals vals)
template<class Graph, class RandomNumGen>
graph_traits< Graph >
::edge_descriptor 
random_edge (Graph &g, RandomNumGen &gen)
template<class Graph, class RandomNumGen>
graph_traits< Graph >
::vertex_descriptor 
random_vertex (Graph &g, RandomNumGen &gen)
template<class Property, class G, class RandomGenerator>
void randomize_property (G &g, RandomGenerator &rg)
template<typename RankMap>
bgl_named_params< RankMap,
vertex_rank_t > 
rank_map (RankMap pmap)
template<typename T, typename IntType>
rational_cast (const rational< IntType > &src)
template<class C>
BOOST_DEDUCED_TYPENAME
range_const_reverse_iterator
< C >::type 
rbegin (const C &c)
template<class C>
BOOST_DEDUCED_TYPENAME
range_reverse_iterator< C >
::type 
rbegin (C &c)
template<class EL, class VL, class D, class VP, class EP, class GP>
GraphParser< adjacency_list
< EL, VL, D, VP, EP, GP >, VP,
EP, VP, EP > 
read (adjacency_list< EL, VL, D, VP, EP, GP > &g)
 graph parser for all internal vertex and edge properties
template<class EL, class VL, class D, class VP, class EP, class GP, class VPS, class EPS>
GraphParser< adjacency_list
< EL, VL, D, VP, EP, GP >, VP,
EP, VPS, EPS > 
read (adjacency_list< EL, VL, D, VP, EP, GP > &g, VPS vps, EPS eps)
 graph parser for given subsets of internal vertex and edge properties
template<class Graph, class CapacityMap, class ReverseEdgeMap>
int read_dimacs_max_flow (Graph &g, CapacityMap capacity, ReverseEdgeMap reverse_edge, typename graph_traits< Graph >::vertex_descriptor &src, typename graph_traits< Graph >::vertex_descriptor &sink)
void read_graphviz (FILE *file, GraphvizDigraph &g)
void read_graphviz (const std::string &file, GraphvizDigraph &g)
template<class Iterator, class T>
void readable_iterator_test (const Iterator i1, T v)
template<class Iterator, class T>
void readable_iterator_traversal_test (const Iterator i1, T v, mpl::false_)
template<class Iterator, class T>
void readable_iterator_traversal_test (Iterator i1, T v, mpl::true_)
template<class DistanceMap, class Tag>
distance_recorder< DistanceMap,
Tag > 
record_distances (DistanceMap pa, Tag)
template<class PredEdgeMap, class Tag>
edge_predecessor_recorder
< PredEdgeMap, Tag > 
record_edge_predecessors (PredEdgeMap pa, Tag)
template<class PredecessorMap, class Tag>
predecessor_recorder
< PredecessorMap, Tag > 
record_predecessors (PredecessorMap pa, Tag)
default_color_type red (default_color_type)
template<class T>
reference_wrapper< T >
BOOST_REF_CONST 
ref (T &t)
BOOST_REGEX_DECL int
BOOST_REGEX_CCALL 
regcompA (regex_tA *expression, const char *ptr, int f)
BOOST_REGEX_DECL int
BOOST_REGEX_CCALL 
regcompW (regex_tW *expression, const wchar_t *ptr, int f)
BOOST_REGEX_DECL regsize_t
BOOST_REGEX_CCALL 
regerrorA (int code, const regex_tA *e, char *buf, regsize_t buf_size)
BOOST_REGEX_DECL regsize_t
BOOST_REGEX_CCALL 
regerrorW (int code, const regex_tW *e, wchar_t *buf, regsize_t buf_size)
template test_string_type regex_format (const match_results< test_string_type::const_iterator > &, const test_string_type &, unsigned flags)
template test_string_type regex_format (const match_results< test_string_type::const_iterator > &m, const char_type *, unsigned flags)
template char_type * regex_format (char_type *, const match_results< ra_it > &m, const test_string_type &fmt, unsigned flags)
template char_type * regex_format (char_type *, const match_results< ra_it > &m, const char_type *fmt, unsigned flags)
template<class Iterator, class Allocator, class charT>
std::basic_string< charT > regex_format (const match_results< Iterator, Allocator > &m, const std::basic_string< charT > &fmt, match_flag_type flags=format_all)
template<class Iterator, class Allocator, class charT>
std::basic_string< charT > regex_format (const match_results< Iterator, Allocator > &m, const charT *fmt, match_flag_type flags=format_all)
template<class OutputIterator, class Iterator, class Allocator, class charT>
OutputIterator regex_format (OutputIterator out, const match_results< Iterator, Allocator > &m, const std::basic_string< charT > &fmt, match_flag_type flags=format_all)
template<class OutputIterator, class Iterator, class Allocator, class charT>
OutputIterator regex_format (OutputIterator out, const match_results< Iterator, Allocator > &m, const charT *fmt, match_flag_type flags=format_all)
template<class Iterator, class Allocator, class charT>
std::basic_string< charT > regex_format (const match_results< Iterator, Allocator > &m, const std::basic_string< charT > &fmt, unsigned flags=0)
template<class Iterator, class Allocator, class charT>
std::basic_string< charT > regex_format (const match_results< Iterator, Allocator > &m, const charT *fmt, unsigned flags=0)
template<class OutputIterator, class Iterator, class Allocator, class charT>
OutputIterator regex_format (OutputIterator out, const match_results< Iterator, Allocator > &m, const std::basic_string< charT > &fmt, unsigned flags=0)
template<class OutputIterator, class Iterator, class Allocator, class charT>
OutputIterator regex_format (OutputIterator out, const match_results< Iterator, Allocator > &m, const charT *fmt, unsigned flags=0)
template unsigned int regex_grep (pred2_type, const test_string_type &, const reg_expression< char_type > &, unsigned flags)
template unsigned int regex_grep (pred1_type, const char_type *, const reg_expression< char_type > &, unsigned flags)
template unsigned int regex_grep (pred1_type, ra_it, ra_it, const reg_expression< char_type > &e, unsigned flags)
template<class Predicate, class ST, class SA, class Allocator, class charT, class traits>
unsigned int regex_grep (Predicate foo, const std::basic_string< charT, ST, SA > &s, const reg_expression< charT, traits, Allocator > &e, match_flag_type flags=match_default)
template<class Predicate, class charT, class Allocator, class traits>
unsigned int regex_grep (Predicate foo, const charT *str, const reg_expression< charT, traits, Allocator > &e, match_flag_type flags=match_default)
template<class Predicate, class BidiIterator, class charT, class traits, class Allocator>
unsigned int regex_grep (Predicate foo, BidiIterator first, BidiIterator last, const reg_expression< charT, traits, Allocator > &e, match_flag_type flags=match_default)
template<class Predicate, class ST, class SA, class Allocator, class charT, class traits>
unsigned int regex_grep (Predicate foo, const std::basic_string< charT, ST, SA > &s, const reg_expression< charT, traits, Allocator > &e, unsigned flags=match_default)
template<class Predicate, class charT, class Allocator, class traits>
unsigned int regex_grep (Predicate foo, const charT *str, const reg_expression< charT, traits, Allocator > &e, unsigned flags=match_default)
template<class Predicate, class iterator, class charT, class traits, class Allocator>
unsigned int regex_grep (Predicate foo, iterator first, iterator last, const reg_expression< charT, traits, Allocator > &e, unsigned flags=match_default)
template bool regex_match (const test_string_type &, const reg_expression< char_type > &, unsigned flags)
template bool regex_match (const char_type *, const reg_expression< char_type > &, unsigned flags)
template bool regex_match (const test_string_type &, match_results< test_string_type::const_iterator > &, const reg_expression< char_type > &, unsigned flags)
template bool regex_match (const char_type *, match_results< const char_type * > &m, const reg_expression< char_type > &e, unsigned flags)
template bool regex_match (ra_it, ra_it, const reg_expression< char_type > &e, unsigned flags)
template bool regex_match (ra_it, ra_it, match_results< ra_it > &m, const reg_expression< char_type > &e, unsigned flags)
template<class ST, class SA, class charT, class traits, class Allocator2>
bool regex_match (const std::basic_string< charT, ST, SA > &s, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class charT, class traits, class Allocator2>
bool regex_match (const charT *str, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
bool regex_match (const std::basic_string< charT, ST, SA > &s, match_results< typename std::basic_string< charT, ST, SA >::const_iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class charT, class Allocator, class traits, class Allocator2>
bool regex_match (const charT *str, match_results< const charT *, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class iterator, class charT, class traits, class Allocator2>
bool regex_match (iterator first, iterator last, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class BidiIterator, class Allocator, class charT, class traits, class Allocator2>
bool regex_match (BidiIterator first, BidiIterator last, match_results< BidiIterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class ST, class SA, class charT, class traits, class Allocator2>
bool regex_match (const std::basic_string< charT, ST, SA > &s, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class charT, class traits, class Allocator2>
bool regex_match (const charT *str, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
bool regex_match (const std::basic_string< charT, ST, SA > &s, match_results< typename std::basic_string< charT, ST, SA >::const_iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class charT, class Allocator, class traits, class Allocator2>
bool regex_match (const charT *str, match_results< const charT *, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class iterator, class charT, class traits, class Allocator2>
bool regex_match (iterator first, iterator last, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class iterator, class Allocator, class charT, class traits, class Allocator2>
bool regex_match (iterator first, iterator last, match_results< iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_merge (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, match_flag_type flags=match_default)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_merge (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, match_flag_type flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_merge (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, match_flag_type flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_merge (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, match_flag_type flags=match_default)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_merge (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, unsigned int flags=match_default)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_merge (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, unsigned int flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_merge (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, unsigned int flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_merge (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, unsigned int flags=match_default)
template test_string_type regex_replace (const test_string_type &, const reg_expression< char_type > &, const test_string_type &, unsigned int flags)
template test_string_type regex_replace (const test_string_type &, const reg_expression< char_type > &, const char_type *, unsigned int flags)
template char_type * regex_replace (char_type *, ra_it, ra_it, const reg_expression< char_type > &e, const test_string_type &, unsigned int flags)
template char_type * regex_replace (char_type *, ra_it, ra_it, const reg_expression< char_type > &, const char_type *, unsigned int flags)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_replace (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, match_flag_type flags=match_default)
template<class traits, class Allocator, class charT>
std::basic_string< charT > regex_replace (const std::basic_string< charT > &s, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, match_flag_type flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_replace (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const std::basic_string< charT > &fmt, match_flag_type flags=match_default)
template<class OutputIterator, class Iterator, class traits, class Allocator, class charT>
OutputIterator regex_replace (OutputIterator out, Iterator first, Iterator last, const reg_expression< charT, traits, Allocator > &e, const charT *fmt, match_flag_type flags=match_default)
template bool regex_search (const test_string_type &, match_results< test_string_type::const_iterator > &, const reg_expression< char_type > &, unsigned flags)
template bool regex_search (const char_type *, match_results< const char_type * > &, const reg_expression< char_type > &, unsigned flags)
template bool regex_search (ra_it, ra_it, match_results< ra_it > &m, const reg_expression< char_type > &e, unsigned flags)
template<class ST, class SA, class charT, class traits, class Allocator2>
bool regex_search (const std::basic_string< charT, ST, SA > &s, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class charT, class traits, class Allocator2>
bool regex_search (const charT *str, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class BidiIterator, class charT, class traits, class Allocator2>
bool regex_search (BidiIterator first, BidiIterator last, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
bool regex_search (const std::basic_string< charT, ST, SA > &s, match_results< typename std::basic_string< charT, ST, SA >::const_iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class charT, class Allocator, class traits, class Allocator2>
bool regex_search (const charT *str, match_results< const charT *, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class BidiIterator, class Allocator, class charT, class traits, class Allocator2>
bool regex_search (BidiIterator first, BidiIterator last, match_results< BidiIterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, match_flag_type flags=match_default)
template<class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
bool regex_search (const std::basic_string< charT, ST, SA > &s, match_results< typename std::basic_string< charT, ST, SA >::const_iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class charT, class Allocator, class traits, class Allocator2>
bool regex_search (const charT *str, match_results< const charT *, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template<class iterator, class Allocator, class charT, class traits, class Allocator2>
bool regex_search (iterator first, iterator last, match_results< iterator, Allocator > &m, const reg_expression< charT, traits, Allocator2 > &e, unsigned flags=match_default)
template std::size_t regex_split (test_string_type *, test_string_type &)
template std::size_t regex_split (test_string_type *, test_string_type &s, const reg_expression< char_type > &e, unsigned flags)
template std::size_t regex_split (test_string_type *, test_string_type &, const reg_expression< char_type > &, unsigned flags, std::size_t)
template<class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
std::size_t regex_split (OutputIterator out, std::basic_string< charT, Traits1, Alloc1 > &s, const reg_expression< charT, Traits2, Alloc2 > &e, match_flag_type flags=match_default)
template<class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
std::size_t regex_split (OutputIterator out, std::basic_string< charT, Traits1, Alloc1 > &s, const reg_expression< charT, Traits2, Alloc2 > &e, match_flag_type flags, std::size_t max_split)
template<class OutputIterator, class charT, class Traits1, class Alloc1>
std::size_t regex_split (OutputIterator out, std::basic_string< charT, Traits1, Alloc1 > &s)
template<class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
std::size_t regex_split (OutputIterator out, std::basic_string< charT, Traits1, Alloc1 > &s, const reg_expression< charT, Traits2, Alloc2 > &e, unsigned flags=match_default)
template<class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
std::size_t regex_split (OutputIterator out, std::basic_string< charT, Traits1, Alloc1 > &s, const reg_expression< charT, Traits2, Alloc2 > &e, unsigned flags, std::size_t max_split)
BOOST_REGEX_DECL int
BOOST_REGEX_CCALL 
regexecA (const regex_tA *expression, const char *buf, regsize_t n, regmatch_t *array, int eflags)
BOOST_REGEX_DECL int
BOOST_REGEX_CCALL 
regexecW (const regex_tW *expression, const wchar_t *buf, regsize_t n, regmatch_t *array, int eflags)
BOOST_REGEX_DECL void
BOOST_REGEX_CCALL 
regfreeA (regex_tA *expression)
BOOST_REGEX_DECL void
BOOST_REGEX_CCALL 
regfreeW (regex_tW *expression)
template<typename Graph, typename CentralityMap>
void relative_betweenness_centrality (const Graph &g, CentralityMap centrality)
template<class Graph, class WeightMap, class PredecessorMap, class DistanceMap>
bool relax (typename graph_traits< Graph >::edge_descriptor e, const Graph &g, WeightMap w, PredecessorMap p, DistanceMap d)
template<class Graph, class WeightMap, class PredecessorMap, class DistanceMap, class BinaryFunction, class BinaryPredicate>
bool relax (typename graph_traits< Graph >::edge_descriptor e, const Graph &g, const WeightMap &w, PredecessorMap &p, DistanceMap &d, const BinaryFunction &combine, const BinaryPredicate &compare)
template<class EdgeList, class Allocator>
void remove_edge (typename detail::val_edge< EdgeList >::type e, std::vector< EdgeList, Allocator > &g)
template<class EdgeList, class Allocator>
void remove_edge (typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector< EdgeList, Allocator > &g)
template<typename G>
void remove_edge (typename subgraph< G >::edge_descriptor e_local, subgraph< G > &g)
template<typename G>
void remove_edge (typename subgraph< G >::vertex_descriptor u_local, typename subgraph< G >::vertex_descriptor v_local, subgraph< G > &g)
template<class vtype, class etype>
void remove_edge (typename graph_traits< leda::GRAPH< vtype, etype > >::edge_descriptor e, leda::GRAPH< vtype, etype > &g)
template<class vtype, class etype>
void remove_edge (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor v, leda::GRAPH< vtype, etype > &g)
template<class EdgeOrIter, class Config>
void remove_edge (EdgeOrIter e, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
void remove_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config>
void remove_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, undirected_graph_helper< Config > &g_)
template<class EdgeOrIter, class Config>
void remove_edge (EdgeOrIter e, undirected_graph_helper< Config > &g_)
template<class EdgeOrIter, class Config>
void remove_edge (EdgeOrIter e_or_iter, directed_graph_helper< Config > &g_)
template<class Config>
void remove_edge (typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, directed_graph_helper< Config > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
void remove_edge (typename adjacency_matrix< D, VP, EP, GP, A >::edge_descriptor e, adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename D, typename VP, typename EP, typename GP, typename A>
void remove_edge (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor v, adjacency_matrix< D, VP, EP, GP, A > &g)
template<class EdgeList, class Allocator, class Predicate>
void remove_edge_if (Predicate p, std::vector< EdgeList, Allocator > &g)
template<typename Predicate, typename G>
void remove_edge_if (Predicate p, subgraph< G > &g)
template<class Predicate, class Config>
void remove_edge_if (Predicate pred, bidirectional_graph_helper< Config > &g_)
template<class Predicate, class Config>
void remove_edge_if (Predicate pred, undirected_graph_helper< Config > &g_)
template<class Config, class Predicate>
void remove_edge_if (Predicate pred, directed_graph_helper< Config > &g_)
template<class Config, class Predicate>
void remove_in_edge_if (typename Config::vertex_descriptor v, Predicate pred, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config, class Predicate>
void remove_in_edge_if (typename Config::vertex_descriptor u, Predicate pred, undirected_graph_helper< Config > &g_)
template<class Config, class Predicate>
void remove_out_edge_if (typename Config::vertex_descriptor u, Predicate pred, bidirectional_graph_helper_with_property< Config > &g_)
template<class Config, class Predicate>
void remove_out_edge_if (typename Config::vertex_descriptor u, Predicate pred, undirected_graph_helper< Config > &g_)
template<class Config, class Predicate>
void remove_out_edge_if (typename Config::vertex_descriptor u, Predicate pred, directed_graph_helper< Config > &g_)
template<class EdgeList, class Allocator>
void remove_vertex (typename EdgeList::value_type u, std::vector< EdgeList, Allocator > &g)
template<typename G>
void remove_vertex (typename subgraph< G >::vertex_descriptor u, subgraph< G > &g)
template<class vtype, class etype>
void remove_vertex (typename graph_traits< leda::GRAPH< vtype, etype > >::vertex_descriptor u, leda::GRAPH< vtype, etype > &g)
template<class Graph, class Config, class Base>
void remove_vertex (typename Config::vertex_descriptor v, vec_adj_list_impl< Graph, Config, Base > &g_)
template<class Derived, class Config, class Base>
void remove_vertex (typename Config::vertex_descriptor u, adj_list_impl< Derived, Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
void remove_vertex (typename adjacency_matrix< D, VP, EP, GP, A >::vertex_descriptor u, adjacency_matrix< D, VP, EP, GP, A > &g)
template<class C>
BOOST_DEDUCED_TYPENAME
range_const_reverse_iterator
< C >::type 
rend (const C &c)
template<class C>
BOOST_DEDUCED_TYPENAME
range_reverse_iterator< C >
::type 
rend (C &c)
int report_errors ()
template<class TT>
void require_boolean_expr (const TT &t)
template<typename Residual_CapacityMap>
bgl_named_params
< Residual_CapacityMap,
edge_residual_capacity_t > 
residual_capacity_map (Residual_CapacityMap pmap)
template<typename ReverseMap>
bgl_named_params< ReverseMap,
edge_reverse_t > 
reverse_edge_map (ReverseMap pmap)
template<class Distance>
unsigned RLS_depth (Distance &d)
template<class Distance, class my_int>
unsigned RLS_max_width (Distance &d, my_int depth)
template<typename Graph>
double rms_wavefront (const Graph &g)
template<typename Graph, typename VertexIndexMap>
double rms_wavefront (const Graph &g, VertexIndexMap index)
template<typename RootMap>
bgl_named_params< RootMap,
vertex_root_t > 
root_map (RootMap pmap)
template<typename Vertex>
bgl_named_params< Vertex,
root_vertex_t > 
root_vertex (const Vertex &r)
template<class Vertex, class DisjointSet>
bool same_component (Vertex u, Vertex v, DisjointSet &ds)
template<class Archive, class T>
void save (Archive &ar, const boost::scoped_ptr< T > &t, const unsigned int)
template<class Archive, class T>
void save (Archive &ar, const boost::optional< T > &t, const unsigned int)
void * search (smart_graph const &g, void *p, vertex_t src, vertex_t dst)
index_entry * seek_type (class_id type)
template<class VertexListGraph, class OrderPA, class ColorMap>
graph_traits< VertexListGraph >
::size_type 
sequential_vertex_coloring (const VertexListGraph &G, OrderPA order, ColorMap color)
template<class Archive, class T>
void serialize (Archive &ar, boost::shared_ptr< T > &t, const unsigned int)
template<class Archive, class T>
void serialize (Archive &ar, boost::scoped_ptr< T > &t, const unsigned int version)
template<class Archive, class T>
void serialize (Archive &ar, boost::optional< T > &t, const unsigned int version)
template<class Iter1, class Iter2, class Iter3>
void serialize_permutation (Iter1 q, Iter1 q_end, Iter2 q_inv, Iter3 p)
template<class K, class C, class A>
void set_clear (std::set< K, C, A > &x)
template<class K, class C, class A>
void set_compliment (const std::set< K, C, A > &x, std::set< K, C, A > &z)
template<class K, class C, class A, class T>
bool set_contains (const std::set< K, C, A > &s, const T &x)
template<class K, class C, class A>
void set_difference (const std::set< K, C, A > &x, const std::set< K, C, A > &y, std::set< K, C, A > &z)
template<class K, class C, class A>
bool set_empty (const std::set< K, C, A > &x)
template<class K, class C, class A>
bool set_equal (const std::set< K, C, A > &x, const std::set< K, C, A > &y)
template<class K, class C, class A, class T>
void set_insert (std::set< K, C, A > &x, const T &a)
template<class K, class C, class A>
void set_intersect (const std::set< K, C, A > &x, const std::set< K, C, A > &y, std::set< K, C, A > &z)
template<class K, class C, class A>
int set_lex_order (const std::set< K, C, A > &x, const std::set< K, C, A > &y)
template<class OEL, class VL, class DS, class VP, class EP, class GP, class EL, class Tag, class Value>
void set_property (adjacency_list< OEL, VL, DS, VP, EP, GP, EL > &g, Tag, const Value &value)
template<class K, class C, class A, class T>
void set_remove (std::set< K, C, A > &x, const T &a)
template<class K, class C, class A>
bool set_subset (const std::set< K, C, A > &x, const std::set< K, C, A > &y)
template<class K, class C, class A>
void set_union (const std::set< K, C, A > &x, const std::set< K, C, A > &y, std::set< K, C, A > &z)
template<class T, class U>
shared_ptr< T > shared_dynamic_cast (shared_ptr< U > const &r)
template<class T, class U>
shared_ptr< T > shared_polymorphic_cast (shared_ptr< U > const &r)
template<class T, class U>
shared_ptr< T > shared_polymorphic_downcast (shared_ptr< U > const &r)
template<class T, class U>
shared_ptr< T > shared_static_cast (shared_ptr< U > const &r)
template<typename T>
detail::graph::edge_or_side
< false, T > 
side_length (T x)
 States that the given quantity is a display area side length.
template<class T>
BOOST_DEDUCED_TYPENAME
range_size< T >::type 
size (const T &r)
template<typename C>
BOOST_RANGE_DEDUCED_TYPENAME
range_size< C >::type 
size (const C &c)
template<typename T>
std::vector< T >::size_type size (const std::vector< T > &c)
template<typename Iter1, typename Iter2>
boost::detail::iterator_traits
< Iter1 >::difference_type 
size (const std::pair< Iter1, Iter2 > &p)
template<typename T, std::size_t sz>
char & sizer (const T BOOST_RANGE_ARRAY_REF()[sz])[sz]
template<class Graph, class OutputIterator, class Color, class Degree, class Priority>
OutputIterator sloan_ordering (Graph &G, OutputIterator permutation, Color color, Degree degree, Priority priority)
template<class Graph, class OutputIterator, class Color, class Degree, class Priority, class Weight>
OutputIterator sloan_ordering (Graph &G, OutputIterator permutation, Color color, Degree degree, Priority priority, Weight W1, Weight W2)
template<class Graph, class OutputIterator, class ColorMap, class DegreeMap, class PriorityMap>
OutputIterator sloan_ordering (Graph &g, typename graph_traits< Graph >::vertex_descriptor s, typename graph_traits< Graph >::vertex_descriptor e, OutputIterator permutation, ColorMap color, DegreeMap degree, PriorityMap priority)
template<class Graph, class OutputIterator, class ColorMap, class DegreeMap, class PriorityMap, class Weight>
OutputIterator sloan_ordering (Graph &g, typename graph_traits< Graph >::vertex_descriptor s, typename graph_traits< Graph >::vertex_descriptor e, OutputIterator permutation, ColorMap color, DegreeMap degree, PriorityMap priority, Weight W1, Weight W2)
template<class Graph, class ColorMap, class DegreeMap>
graph_traits< Graph >
::vertex_descriptor 
sloan_start_end_vertices (Graph &G, typename graph_traits< Graph >::vertex_descriptor &s, ColorMap color, DegreeMap degree)
template<class VertexListGraph, class Order, class Degree, class Marker, class BucketSorter>
void smallest_last_vertex_ordering (const VertexListGraph &G, Order order, Degree degree, Marker marker, BucketSorter &degree_buckets)
template<class VertexListGraph, class Order, class Degree, class Marker>
void smallest_last_vertex_ordering (const VertexListGraph &G, Order order, Degree degree, Marker marker)
template<class T, class U>
static T smart_cast (U u)
template<class T, class U>
static T smart_cast_reference (U &u)
template<typename Container, typename Predicate>
void sort (Container &c, const Predicate &p)
template<typename Container>
void sort (Container &c)
template<class Iter, class IterP>
void sortp (Iter first, Iter last, IterP p)
template<class Iter, class IterP, class Cmp>
void sortp (Iter first, Iter last, IterP p, Cmp cmp)
template<class Iter, class IterP, class Cmp, class Alloc>
void sortp (Iter first, Iter last, IterP p, Cmp cmp, Alloc alloc)
template<class Iter, class IterP, class Cmp, class Alloc>
void sortv (Iter first, Iter last, IterP p, Cmp cmp, Alloc alloc)
template<typename G>
graph_traits< G >
::vertex_descriptor 
source (typename graph_traits< G >::edge_descriptor e_local, const subgraph< G > &g)
template<class Edge, class BidirectionalGraph, class GRef>
graph_traits
< BidirectionalGraph >
::vertex_descriptor 
source (const Edge &e, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_descriptor 
source (typename graph_traits< leda::GRAPH< vtype, etype > >::edge_descriptor e, const leda::GRAPH< vtype, etype > &g)
template<typename V, typename D, typename P, typename B>
source (const typename incidence_graph_archetype< V, D, P, B >::edge_descriptor &, const incidence_graph_archetype< V, D, P, B > &)
template<typename G>
filtered_graph_base< G >
::vertex_descriptor 
source (typename filtered_graph_base< G >::edge_descriptor e, const filtered_graph_base< G > &g)
template<class G, class EI, class T, class D>
edge_list_impl_ra< G, EI, T, D >
::vertex_descriptor 
source (typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e, const edge_list_impl_ra< G, EI, T, D > &g_)
template<class G, class EI, class T, class D>
edge_list_impl< G, EI, T, D >
::vertex_descriptor 
source (typename edge_list_impl< G, EI, T, D >::edge_descriptor e, const edge_list_impl< G, EI, T, D > &)
template<typename D, typename VP, typename EP, typename GP, typename A, typename Dir, typename Vertex>
adjacency_matrix< D, VP, EP,
GP, A >::vertex_descriptor 
source (const detail::matrix_edge_desc_impl< Dir, Vertex > &e, const adjacency_matrix< D, VP, EP, GP, A > &)
template<class Directed, class Vertex, class OutEdgeListS, class VertexListS, class DirectedS, class VertexProperty, class EdgeProperty, class GraphProperty, class EdgeListS>
Vertex source (const detail::edge_base< Directed, Vertex > &e, const adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > &)
template<typename Container, typename Predicate>
void stable_sort (Container &c, const Predicate &p)
template<typename Container>
void stable_sort (Container &c)
template<class TimeMap, class TimeT, class Tag>
time_stamper< TimeMap, TimeT, Tag > stamp_times (TimeMap pa, TimeT &time_counter, Tag)
template<class T, class U>
shared_ptr< T > static_pointer_cast (shared_ptr< U > const &r)
template<class T, class U>
intrusive_ptr< T > static_pointer_cast (intrusive_ptr< U > const &p)
template<class Ch, class Tr, class Alloc>
std::basic_string< Ch, Tr, Alloc > str (const basic_format< Ch, Tr, Alloc > &f)
template<typename Container>
void stringtok (Container &l, std::string const &s, char const *const ws=" \t\n")
template<class Graph, class ComponentMap>
property_traits< ComponentMap >
::value_type 
strong_components (const Graph &g, ComponentMap comp)
template<class Graph, class ComponentMap, class P, class T, class R>
property_traits< ComponentMap >
::value_type 
strong_components (const Graph &g, ComponentMap comp, const bgl_named_params< P, T, R > &params)
template<class T>
void swap (weak_ptr< T > &a, weak_ptr< T > &b)
template<BOOST_VARIANT_ENUM_PARAMS(typename T) >
void swap (variant< BOOST_VARIANT_ENUM_PARAMS(T) > &lhs, variant< BOOST_VARIANT_ENUM_PARAMS(T) > &rhs)
template<typename T>
void swap (recursive_wrapper< T > &lhs, recursive_wrapper< T > &rhs)
template<class T>
void swap (scoped_ptr< T > &a, scoped_ptr< T > &b)
template<class T>
void swap (scoped_array< T > &a, scoped_array< T > &b)
template<class BidiIterator, class Allocator>
void swap (match_results< BidiIterator, Allocator > &a, match_results< BidiIterator, Allocator > &b)
template<class charT, class traits, class Allocator>
void swap (reg_expression< charT, traits, Allocator > &a, reg_expression< charT, traits, Allocator > &b)
template<class T>
void swap (optional< T > &x, optional< T > &y)
template<class T>
void swap (intrusive_ptr< T > &lhs, intrusive_ptr< T > &rhs)
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS, typename Allocator>
void swap (BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &f1, BOOST_FUNCTION_FUNCTION< R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator > &f2)
template<typename Signature, typename Allocator>
void swap (function< Signature, Allocator > &f1, function< Signature, Allocator > &f2)
template<typename Block, typename Allocator>
void swap (dynamic_bitset< Block, Allocator > &b1, dynamic_bitset< Block, Allocator > &b2)
template<class T>
void swap (shared_ptr< T > &a, shared_ptr< T > &b)
template<class T>
void swap (shared_array< T > &a, shared_array< T > &b)
template<class T1, class T2>
void swap (compressed_pair< T1, T2 > &x, compressed_pair< T1, T2 > &y)
template<class T, std::size_t N>
void swap (array< T, N > &x, array< T, N > &y)
template<class Iterator>
void swappable_iterator_test (Iterator i, Iterator j)
template<typename G>
graph_traits< G >
::vertex_descriptor 
target (typename graph_traits< G >::edge_descriptor e_local, const subgraph< G > &g)
template<class Edge, class BidirectionalGraph, class GRef>
graph_traits
< BidirectionalGraph >
::vertex_descriptor 
target (const Edge &e, const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_descriptor 
target (typename graph_traits< leda::GRAPH< vtype, etype > >::edge_descriptor e, const leda::GRAPH< vtype, etype > &g)
template<typename V, typename D, typename P, typename B>
target (const typename incidence_graph_archetype< V, D, P, B >::edge_descriptor &, const incidence_graph_archetype< V, D, P, B > &)
template<typename G>
filtered_graph_base< G >
::vertex_descriptor 
target (typename filtered_graph_base< G >::edge_descriptor e, const filtered_graph_base< G > &g)
template<class G, class EI, class T, class D>
edge_list_impl_ra< G, EI, T, D >
::vertex_descriptor 
target (typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e, const edge_list_impl_ra< G, EI, T, D > &g_)
template<class G, class EI, class T, class D>
edge_list_impl< G, EI, T, D >
::vertex_descriptor 
target (typename edge_list_impl< G, EI, T, D >::edge_descriptor e, const edge_list_impl< G, EI, T, D > &)
template<typename D, typename VP, typename EP, typename GP, typename A, typename Dir, typename Vertex>
adjacency_matrix< D, VP, EP,
GP, A >::vertex_descriptor 
target (const detail::matrix_edge_desc_impl< Dir, Vertex > &e, const adjacency_matrix< D, VP, EP, GP, A > &)
template<class Directed, class Vertex, class OutEdgeListS, class VertexListS, class DirectedS, class VertexProperty, class EdgeProperty, class GraphProperty, class EdgeListS>
Vertex target (const detail::edge_base< Directed, Vertex > &e, const adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty, GraphProperty, EdgeListS > &)
void throw_exception ()
 throw_exception (filesystem_error("boost::filesystem::copy_file", from_file_ph, to_file_ph, fs::detail::system_error_code()))
template<class E>
void throw_exception (E const &e)
BOOST_PROGRAM_OPTIONS_DECL
std::string 
to_8_bit (const std::wstring &s, const std::codecvt< wchar_t, char, std::mbstate_t > &cvt)
template<typename Block, typename Allocator, typename BlockOutputIterator>
void to_block_range (const dynamic_bitset< Block, Allocator > &b, BlockOutputIterator result)
BOOST_PROGRAM_OPTIONS_DECL
std::string 
to_local_8_bit (const std::wstring &s)
std::string to_string (const char *i, const char *j)
template<class iterator>
std::string to_string (iterator i, iterator j)
template<typename Block, typename Allocator, typename stringT>
void to_string (const dynamic_bitset< Block, Allocator > &b, stringT &s)
template<typename B, typename A, typename stringT>
void to_string_helper (const dynamic_bitset< B, A > &b, stringT &s, bool dump_all)
BOOST_PROGRAM_OPTIONS_DECL
std::string 
to_utf8 (const std::wstring &s)
template<typename VertexListGraph, typename OutputIterator>
void topological_sort (VertexListGraph &g, OutputIterator result)
template<typename VertexListGraph, typename OutputIterator, typename P, typename T, typename R>
void topological_sort (VertexListGraph &g, OutputIterator result, const bgl_named_params< P, T, R > &params)
template<typename SeqT, typename Range, typename FuncT>
SeqT transform_range (const Range &r, FuncT Func)
 transform a range into a sequence
template<typename Graph, typename GraphTC, typename P, typename T, typename R>
void transitive_closure (const Graph &g, GraphTC &tc, const bgl_named_params< P, T, R > &params)
template<typename Graph, typename GraphTC>
void transitive_closure (const Graph &g, GraphTC &tc)
template<typename Graph, typename GraphTC, typename G_to_TC_VertexMap, typename VertexIndexMap>
void transitive_closure (const Graph &g, GraphTC &tc, G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map)
template<class VertexListGraph, class MutableGraph, class P, class T, class R>
void transpose_graph (const VertexListGraph &G, MutableGraph &G_T, const bgl_named_params< P, T, R > &params)
template<class VertexListGraph, class MutableGraph>
void transpose_graph (const VertexListGraph &G, MutableGraph &G_T)
template<class Tree, class TreeVisitor>
void traverse_tree (typename tree_traits< Tree >::node_descriptor v, Tree &t, TreeVisitor visitor)
template<class Iterator, class T>
void trivial_iterator_test (const Iterator i, const Iterator j, T val)
type_index_t & type_index ()
type_index_t::iterator type_position (class_id type)
template<typename IncidenceGraph, typename DFSVisitor, typename VertexColorMap, typename EdgeColorMap>
void undirected_depth_first_visit (const IncidenceGraph &g, typename graph_traits< IncidenceGraph >::vertex_descriptor u, DFSVisitor vis, VertexColorMap vertex_color, EdgeColorMap edge_color)
template<typename Graph, typename P, typename T, typename R>
void undirected_dfs (const Graph &g, const bgl_named_params< P, T, R > &params)
template<typename Graph, typename DFSVisitor, typename VertexColorMap, typename EdgeColorMap>
void undirected_dfs (const Graph &g, DFSVisitor vis, VertexColorMap vertex_color, EdgeColorMap edge_color)
template<typename Graph, typename DFSVisitor, typename VertexColorMap, typename EdgeColorMap, typename Vertex>
void undirected_dfs (const Graph &g, DFSVisitor vis, VertexColorMap vertex_color, EdgeColorMap edge_color, Vertex start_vertex)
template<class T>
void unused_variable (const T &)
smart_graph & up_graph ()
template<class TreeNode, class Compare, class ExternalData>
TreeNode up_heap (TreeNode x, const Compare &comp, ExternalData &edata)
template<class TreeNode, class Compare, class ExternalData>
void update_heap (TreeNode x, const Compare &comp, ExternalData &edata)
template<typename Graph1, typename Graph2, typename IsoMap>
bool verify_isomorphism (const Graph1 &g1, const Graph2 &g2, IsoMap iso_map)
template<typename G>
subgraph< G >::vertex_descriptor vertex (typename subgraph< G >::vertices_size_type n, const subgraph< G > &g)
Vertex * vertex (long v, sgb_const_graph_ptr g)
template<class Graph, class Config, class Base>
Config::vertex_descriptor vertex (typename Config::vertices_size_type n, const vec_adj_list_impl< Graph, Config, Base > &)
template<class Derived, class Config, class Base>
Config::vertex_descriptor vertex (typename Config::vertices_size_type n, const adj_list_impl< Derived, Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
adjacency_matrix< D, VP, EP,
GP, A >::vertex_descriptor 
vertex (typename adjacency_matrix< D, VP, EP, GP, A >::vertices_size_type n, const adjacency_matrix< D, VP, EP, GP, A > &g)
template<typename Copier>
bgl_named_params< Copier,
vertex_copy_t > 
vertex_copy (const Copier &c)
template<typename IndexMap>
bgl_named_params< IndexMap,
vertex_index1_t > 
vertex_index1_map (const IndexMap &pmap)
template<typename IndexMap>
bgl_named_params< IndexMap,
vertex_index2_t > 
vertex_index2_map (const IndexMap &pmap)
template<typename IndexMap>
bgl_named_params< IndexMap,
vertex_index_t > 
vertex_index_map (IndexMap pmap)
template<typename VertexInvar>
bgl_named_params< VertexInvar,
vertex_invariant_t > 
vertex_invariant (const VertexInvar &c)
template<class EdgeList, class Alloc>
std::pair< typename
boost::integer_range< typename
EdgeList::value_type >
::iterator, typename
boost::integer_range< typename
EdgeList::value_type >
::iterator > 
vertices (const std::vector< EdgeList, Alloc > &v)
template<typename G>
std::pair< typename subgraph
< G >::vertex_iterator,
typename subgraph< G >
::vertex_iterator > 
vertices (const subgraph< G > &g)
std::pair< sgb_vertex_iterator,
sgb_vertex_iterator > 
vertices (sgb_const_graph_ptr g)
template<class BidirectionalGraph, class GRef>
std::pair< typename
reverse_graph
< BidirectionalGraph >
::vertex_iterator, typename
reverse_graph
< BidirectionalGraph >
::vertex_iterator > 
vertices (const reverse_graph< BidirectionalGraph, GRef > &g)
template<class vtype, class etype>
std::pair< typename
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_iterator, typename
graph_traits< leda::GRAPH
< vtype, etype >
>::vertex_iterator > 
vertices (const leda::GRAPH< vtype, etype > &g)
template<class T>
T::ThereReallyIsNoMemberByThisNameInT vertices (T const &)
template<typename V, typename D, typename P, typename B>
std::pair< typename
vertex_list_graph_archetype< V,
D, P, B >::vertex_iterator,
typename
vertex_list_graph_archetype< V,
D, P, B >::vertex_iterator > 
vertices (const vertex_list_graph_archetype< V, D, P, B > &)
template<typename G, typename EP, typename VP>
std::pair< typename
filtered_graph< G, EP, VP >
::vertex_iterator, typename
filtered_graph< G, EP, VP >
::vertex_iterator > 
vertices (const filtered_graph< G, EP, VP > &g)
template<class Config, class Base>
std::pair< typename
Config::vertex_iterator,
typename
Config::vertex_iterator > 
vertices (const adj_list_helper< Config, Base > &g_)
template<typename D, typename VP, typename EP, typename GP, typename A>
std::pair< typename
adjacency_matrix< D, VP, EP,
GP, A >::vertex_iterator,
typename adjacency_matrix< D,
VP, EP, GP, A >
::vertex_iterator > 
vertices (const adjacency_matrix< D, VP, EP, GP, A > &g_)
template<typename V>
void visit_each (V &v, const tracking_bridge &t, int)
template<class V, class T>
void visit_each (V &v, T const &t, long)
template<typename Visitor, typename T>
void visit_each (Visitor &visitor, const T &t)
template<typename Visitor, typename T>
void visit_each (Visitor &visitor, const T &t, long)
template<class V, class R, class F, class L>
void visit_each (V &v, _bi::bind_t< R, F, L > const &t, int)
template<class V, class T>
void visit_each (V &v, _bi::value< T > const &t, int)
template<class Triangle, class HList, class Iterator>
SAW_visitor< Triangle, HList,
Iterator > 
visit_SAW (Triangle t, HList hl, Iterator i)
template<class Tri, class HList, class Iter>
SAW_visitor
< random_access_iterator_property_map
< Tri *, Tri, Tri & >, HList,
random_access_iterator_property_map
< Iter *, Iter, Iter & > > 
visit_SAW_ptr (Tri *t, HList hl, Iter *i)
template<typename Visitor>
bgl_named_params< Visitor,
graph_visitor_t > 
visitor (const Visitor &vis)
template<typename R, typename T>
visitor_ptr_t< T, R > visitor_ptr (R(*visitor)(T))
template<typename G>
void warren_transitive_closure (G &g)
template<typename G>
void warshall_transitive_closure (G &g)
template<typename WeightMap>
bgl_named_params< WeightMap,
edge_weight_t > 
weight_map (WeightMap pmap)
template<typename WeightMap>
bgl_named_params< WeightMap,
edge_weight2_t > 
weight_map2 (WeightMap pmap)
default_color_type white (default_color_type)
template<class Iterator, class T>
void writable_iterator_test (Iterator i, T v, T v2)
template<class Iterator, class T>
void writable_iterator_traversal_test (const Iterator i1, T v, mpl::false_)
template<class Iterator, class T>
void writable_iterator_traversal_test (Iterator i1, T v, mpl::true_)
template<class EL, class VL, class D, class VP, class EP, class GP>
GraphPrinter< adjacency_list
< EL, VL, D, VP, EP, GP >, VP,
EP > 
write (adjacency_list< EL, VL, D, VP, EP, GP > &g)
 write the graph with all internal vertex and edge properties
template<class EL, class VL, class D, class VP, class EP, class GP, class VPS, class EPS>
GraphPrinter< adjacency_list
< EL, VL, D, VP, EP, GP >, VPS,
EPS > 
write (adjacency_list< EL, VL, D, VP, EP, GP > &g, VPS, EPS)
 write the graph with given property subsets
void write_all_attributes (detail::error_property_not_found, const std::string &, std::ostream &)
template<typename Attributes>
void write_all_attributes (Attributes attributes, const std::string &name, std::ostream &out)
template<class Attribute>
void write_attributes (const Attribute &attr, std::ostream &out)
template<typename Graph>
void write_graphviz (const std::string &filename, const subgraph< Graph > &g)
template<typename Graph>
void write_graphviz (std::ostream &out, const subgraph< Graph > &g)
template<typename Graph, typename VertexWriter, typename EdgeWriter>
void write_graphviz (std::ostream &out, const Graph &g, VertexWriter vw, EdgeWriter ew)
template<typename Graph, typename VertexWriter>
void write_graphviz (std::ostream &out, const Graph &g, VertexWriter vw)
template<typename Graph>
void write_graphviz (std::ostream &out, const Graph &g)
template<typename Graph, typename VertexPropertiesWriter, typename EdgePropertiesWriter, typename GraphPropertiesWriter>
void write_graphviz (std::ostream &out, const Graph &g, VertexPropertiesWriter vpw, EdgePropertiesWriter epw, GraphPropertiesWriter gpw)
template<class PA, class OutputIterator, class Tag>
property_writer< PA,
OutputIterator, Tag > 
write_property (PA pa, OutputIterator out, Tag)
int xtime_cmp (const xtime &xt1, const xtime &xt2)
int BOOST_THREAD_DECL xtime_get (struct xtime *xtp, int clock_type)

Variables

 E
struct boost::edge_component_t edge_component
const int exit_exception_failure = 200
const int exit_failure = EXIT_FAILURE
const int exit_success = EXIT_SUCCESS
const int exit_test_failure = 201
multi_array_types::extent_gen extents
regex::flag_type f
D const & i
multi_array_types::index_gen indices
unsigned int magic_value = 25631
const char * names []
detail::none_t const none = ((detail::none_t)0)
T & out
 R
T const variant
< BOOST_VARIANT_ENUM_PARAMS(U) > & 
rhs
 T
 TC
BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT * TimesOpConcept
boost::program_options::detail::utf8_codecvt_facet
< wchar_t, char > 
utf8_facet
 V
Visitable1 & visitable1
unsigned int wmagic_value = 28631
const wchar_t * wnames []


Generated by  Doxygen 1.6.0   Back to index