Spatial C++ Library
Generic Multi-Dimensional Containers and Spatial Operations
spatial Namespace Reference

The main namespace used in the library. More...

Namespaces

 details
 Defines the namespace that contains all implementation-level utilities needed by the component of the library.
 
 except
 
 import
 
 math
 

Classes

struct  accessor_less
 A comparator that simplifies using the spatial containers with a Key type that has coordinate that are not accessible via the bracket, parenthesis operator or iterator deference. More...
 
struct  accessor_minus
 This functor uses the minus operator to calculate the difference between 2 elements of Tp along the dimension n accessed through a custom accessor. More...
 
struct  arithmetic_error
 Thrown to report that an arithmetic error has occured during a calculation. More...
 
class  bounds
 A model of Region Predicate that defines an orthogonal region and checks if a value of type Key is contained within the boundaries marked by lower and upper. More...
 
class  box_multimap
 A mapped containers to store values in space that can be represented as boxes. More...
 
struct  box_multimap< 0, Key, Mapped, Compare, BalancingPolicy, Alloc >
 Specialization for spatial::box_multimap with runtime rank support. More...
 
class  box_multiset
 These containers are not mapped containers and store values in space that can be represented as boxes. More...
 
class  box_multiset< 0, Key, Compare, BalancingPolicy, Alloc >
 Specialization for spatial::box_multiset with runtime rank support. More...
 
struct  bracket_less
 A comparator that simplifies using the spatial containers with a Key type that has coordiates accessible via the bracket operator. More...
 
struct  bracket_minus
 This functor uses the minus operator to calculate the difference between 2 elements of Tp along the dimension n accessed through the bracket operator. More...
 
class  closed_bounds
 A model of Region Predicate that checks if a value of type Key is contained within the closed boundaries defined by lower and upper. More...
 
struct  closed_region_iterator
 
struct  closed_region_iterator< const Ct >
 
struct  closed_region_iterator_pair
 
struct  closed_region_iterator_pair< const Ct >
 
struct  container_traits
 The traits type for all containers in the spatial namespace. More...
 
struct  enable_if
 
struct  enable_if_c
 If B is true, spatial::enable_if has a public member typedef type, equal to Tp; otherwise, there is no member typedef. More...
 
struct  enable_if_c< true, Tp >
 
class  enclosed_bounds
 This region predicate matches keys that are enclosed or equal to a target box. More...
 
struct  enclosed_region_iterator
 
struct  enclosed_region_iterator< const Ct, Layout >
 
struct  enclosed_region_iterator_pair
 
struct  enclosed_region_iterator_pair< const Ct, Layout >
 
class  equal_iterator
 This type provides an iterator to iterate through all elements of a container that match a given key, passed as a parameter to the constructor. More...
 
class  equal_iterator< const Container >
 This type provides an iterator to iterate through all elements of a container that match a given key, passed as a parameter to the constructor. More...
 
struct  equal_iterator_pair
 This structure defines a pair of mutable equal iterator. More...
 
struct  equal_iterator_pair< const Container >
 This structure defines a pair of constant equal iterator. More...
 
class  euclidian
 Defines a metric working on the Euclidian space where distances are expressed in one of C++'s floating point types. More...
 
class  euclidian_neighbor_iterator
 Facilitate the creation of neighbor iterator that works with an euclidian metric. More...
 
class  euclidian_neighbor_iterator< const Ct, DistanceType, Diff >
 
class  euclidian_neighbor_iterator_pair
 Facilitate the creation of an iterator range representing a sequence from closest to furthest from the target key position, in euclidian space. More...
 
class  euclidian_neighbor_iterator_pair< const Ct, DistanceType, Diff >
 
struct  hhll_layout_tag
 Represents a coordinate layout for the box. More...
 
struct  hlhl_layout_tag
 Represents a coordinate layout for the box. More...
 
class  idle_box_multimap
 
class  idle_box_multimap< 0, Key, Mapped, Compare, Alloc >
 Specialization for spatial::idle_box_multimap with runtime rank support. More...
 
class  idle_box_multiset
 Non-associative containers that and store values in space that can be represented as boxes. More...
 
class  idle_box_multiset< 0, Key, Compare, Alloc >
 Specialization for spatial::idle_box_multiset with runtime rank support. More...
 
struct  idle_point_multimap
 These containers are mapped containers and store values in space that can be represented as points. More...
 
struct  idle_point_multimap< 0, Key, Mapped, Compare, Alloc >
 When specified with a null dimension, the rank of the point_multimap can be determined at run time and is not fixed at compile time. More...
 
struct  idle_point_multiset
 
struct  idle_point_multiset< 0, Key, Compare, Alloc >
 Specialization for spatial::idle_point_multiset with runtime rank support. More...
 
struct  invalid_bounds
 Thrown to report that an invalid range bound has been given as argument. More...
 
struct  invalid_box
 Thrown to report that a box has incorrect coordinates with regards to its layout. More...
 
struct  invalid_dimension
 Thrown to report that an invalid dimension was passed as an argument. More...
 
struct  invalid_distance
 Thrown to report that an negative distance has been passed as a parameter while distances are expected to be positive. More...
 
struct  invalid_empty_container
 Thrown to report that an empty container was passed as an argument, while the function does not accept an empty container. More...
 
struct  invalid_iterator
 Thrown to report that an invalid iterator was passed as an argument. More...
 
struct  invalid_node
 Thrown to report that an invalid node was passed as an argument. More...
 
struct  invalid_odd_rank
 Thrown to report that an odd rank value was passed as a argument. More...
 
struct  invalid_rank
 Thrown to report that an invalid rank was passed as an argument. More...
 
struct  iterator_less
 A comparator that simplifies using the spatial containers with a Key type that has coordiates accessible via iterator deference. More...
 
struct  iterator_minus
 This functor uses the minus operator to calculate the difference between 2 elements of Tp along the dimension n accessed through an iterator. More...
 
struct  lhlh_layout_tag
 Represents a coordinate layout for the box. More...
 
struct  llhh_layout_tag
 Represents a coordinate layout for the box. More...
 
struct  loose_balancing
 This policy triggers rebalancing for the node when the difference in weight between left or right is more than a half. More...
 
class  manhattan
 Defines a metric for the a space where distances are the sum of all the elements of the vector. More...
 
class  manhattan_neighbor_iterator
 Facilitate the creation of neighbor iterator that works with a manhattan metric. More...
 
class  manhattan_neighbor_iterator< const Ct, DistanceType, Diff >
 
class  manhattan_neighbor_iterator_pair
 Facilitate the creation of an iterator range representing a sequence from closest to furthest from the target key position, in manhattan space. More...
 
class  manhattan_neighbor_iterator_pair< const Ct, DistanceType, Diff >
 
class  mapping_iterator
 This iterator walks through all items in the container in order from the lowest to the highest value along a particular dimension. More...
 
class  mapping_iterator< const Ct >
 This iterator walks through all items in the container in order from the lowest to the highest value along a particular dimension. More...
 
struct  mapping_iterator_pair
 This structure defines a pair of mutable mapping iterator. More...
 
struct  mapping_iterator_pair< const Ct >
 This structure defines a pair of constant mapping iterator. More...
 
struct  metric_traits
 The traits type for all metrics in the spatial namespace. More...
 
struct  mode_traits
 
class  neighbor_iterator
 A spatial iterator for a container Ct that goes through the nearest to the furthest element from a target key, with distances applied according to a user-defined geometric space that is a model of Metric. More...
 
class  neighbor_iterator< const Ct, Metric >
 A spatial iterator for a container Ct that goes through the nearest to the furthest element from a target key, with distances applied according to a user-defined geometric space of type Metric. More...
 
struct  neighbor_iterator_pair
 This structure defines a pair of neighbor iterator. More...
 
struct  neighbor_iterator_pair< const Ct, Metric >
 This structure defines a pair of constant neighbor iterator. More...
 
class  open_bounds
 A model of Region Predicate that checks if a value of type Key is contained within the open boundaries defined by lower and upper. More...
 
struct  open_region_iterator
 
struct  open_region_iterator< const Ct >
 
struct  open_region_iterator_pair
 
struct  open_region_iterator_pair< const Ct >
 
class  ordered_iterator
 All elements returned by this iterator are ordered from the smallest to the largest value of their key's coordinate along a single dimension. More...
 
class  ordered_iterator< const Ct >
 All elements returned by this iterator are ordered from the smallest to the largest value of their key's coordinate along a single dimension, called the ordered dimension. More...
 
struct  ordered_iterator_pair
 This structure defines a pair of mutable spatial::ordered_iterator. More...
 
struct  ordered_iterator_pair< const Ct >
 This structure defines a pair of constant ordered iterator. More...
 
class  overlap_bounds
 This class is a model of Region Predicate that matches any keys that is overlapping with a given test box. More...
 
struct  overlap_region_iterator
 
struct  overlap_region_iterator< const Ct, Layout >
 
struct  overlap_region_iterator_pair
 
struct  overlap_region_iterator_pair< const Ct, Layout >
 
struct  paren_less
 A comparator that simplifies using the spatial containers with a Key type that has coordiates accessible via the parenthesis operator. More...
 
struct  paren_minus
 This functor uses the minus operator to calculate the difference between 2 elements of Tp along the dimension n accessed through the parenthesis operator. More...
 
struct  perfect_balancing
 A policy that balances a node if the difference in weight between left and right is higher than 2 (two). More...
 
struct  point_multimap
 These containers are mapped containers and store values in space that can be represented as points. More...
 
struct  point_multimap< 0, Key, Mapped, Compare, BalancingPolicy, Alloc >
 When specified with a null dimension, the rank of the point_multimap can be determined at run time and does not need to be fixed at compile time. More...
 
struct  point_multiset
 
struct  point_multiset< 0, Key, Compare, BalancingPolicy, Alloc >
 Specialization for spatial::point_multiset with runtime rank support. More...
 
class  quadrance
 Defines a metric in the Euclidian space where only the square of the distances are being computed into a scalar value expressed with the DistanceType which is one of C++'s arithmetic types. More...
 
class  quadrance_neighbor_iterator
 Facilitate the creation of neighbor iterator that works with a quadrance metric. More...
 
class  quadrance_neighbor_iterator< const Ct, DistanceType, Diff >
 
class  quadrance_neighbor_iterator_pair
 Facilitate the creation of an iterator range representing a sequence from closest to furthest from the target key position, in quadrance space. More...
 
class  quadrance_neighbor_iterator_pair< const Ct, DistanceType, Diff >
 
class  region_iterator
 This type provides both an iterator and a constant iterator to iterate through all elements of a tree that match an orthogonal region defined by a predicate. More...
 
class  region_iterator< const Ct, Predicate >
 This type provides both an iterator and a constant iterator to iterate through all elements of a tree that match an orthogonal region defined by a predicate. More...
 
struct  region_iterator_pair
 This structure defines a pair of mutable region iterator. More...
 
struct  region_iterator_pair< const Ct, Predicate >
 This structure defines a pair of constant region iterator. More...
 
struct  tight_balancing
 A policy that balances a node if the difference in weight between left and right is higher than the current rank of the tree. More...
 

Typedefs

typedef std::size_t size_type
 Defines a positive integral type for counting objects or storing absolute values. More...
 
typedef std::size_t dimension_type
 Defines the type for the dimension as being a size. More...
 
typedef std::size_t weight_type
 Defines weight as being a size. More...
 

Enumerations

enum  relative_order { below = -1, matching = 0, above = 1 }
 Defines values for relative ordering. More...
 

Functions

template<typename Container >
std::pair< std::size_t > minmax_depth (const Container &container)
 Returns a pair containing the minimum (as first) and maximum (as second) depth found in the container's tree. More...
 
template<typename Iterator >
std::size_t depth (const Iterator &iterator)
 Returns the depth of a node's iterator. More...
 
template<typename Tp >
closed_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare > make_closed_bounds (const Tp &container, const typename container_traits< Tp >::key_type &lower, const typename container_traits< Tp >::key_type &upper)
 A closed_bounds factory that takes in a container, a region defined by lower and upper, and returns a constructed closed_bounds object. More...
 
template<typename Ct >
closed_region_iterator< Ct > closed_region_end (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator< const Ct > closed_region_end (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator< const Ct > closed_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator< Ct > closed_region_begin (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator< const Ct > closed_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator< const Ct > closed_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator_pair< Ct > closed_region_range (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator_pair< const Ct > closed_region_range (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
closed_region_iterator_pair< const Ct > closed_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
enclosed_region_iterator< Ct > enclosed_region_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< Ct, Layout > enclosed_region_end (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator< const Ct > enclosed_region_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< const Ct, Layout > enclosed_region_end (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator< const Ct > enclosed_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< const Ct, Layout > enclosed_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator< Ct > enclosed_region_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< Ct, Layout > enclosed_region_begin (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator< const Ct > enclosed_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< const Ct, Layout > enclosed_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator< const Ct > enclosed_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator< const Ct, Layout > enclosed_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator_pair< Ct > enclosed_region_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator_pair< Ct, Layout > enclosed_region_range (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator_pair< const Ct > enclosed_region_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator_pair< const Ct, Layout > enclosed_region_range (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
enclosed_region_iterator_pair< const Ct > enclosed_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
enclosed_region_iterator_pair< const Ct, Layout > enclosed_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Container >
equal_iterator< Container > equal_end (Container &container, const typename equal_iterator< Container >::key_type &value)
 
template<typename Container >
equal_iterator< const Container > equal_cend (const Container &container, const typename equal_iterator< Container >::key_type &value)
 
template<typename Ct , typename Metric >
const container_traits< Ct >::key_type & target_key (const neighbor_iterator< Ct, Metric > &iter)
 A quick accessor for neighbor iterators that retrive the key that is the target for the nearest neighbor iteration. More...
 
template<typename Tp >
open_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare > make_open_bounds (const Tp &container, const typename container_traits< Tp >::key_type &lower, const typename container_traits< Tp >::key_type &upper)
 A open_bounds factory that takes in a container, a region defined by lower and upper, and returns a constructed open_bounds object. More...
 
template<typename Ct >
open_region_iterator< Ct > open_region_end (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator< const Ct > open_region_end (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator< const Ct > open_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator< Ct > open_region_begin (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator< const Ct > open_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator< const Ct > open_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator_pair< Ct > open_region_range (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator_pair< const Ct > open_region_range (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
open_region_iterator_pair< const Ct > open_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Container >
ordered_iterator< Container > ordered_end (Container &container)
 Finds the past-the-end position in container for this constant iterator. More...
 
template<typename Container >
ordered_iterator< Container > ordered_begin (Container &container)
 Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim. More...
 
template<typename Ct >
overlap_region_iterator< Ct > overlap_region_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< Ct, Layout > overlap_region_end (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator< const Ct > overlap_region_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< const Ct, Layout > overlap_region_end (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator< const Ct > overlap_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< const Ct, Layout > overlap_region_cend (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator< Ct > overlap_region_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< Ct, Layout > overlap_region_begin (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator< const Ct > overlap_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< const Ct, Layout > overlap_region_begin (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator< const Ct > overlap_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator< const Ct, Layout > overlap_region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator_pair< Ct > overlap_region_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator_pair< Ct, Layout > overlap_region_range (Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator_pair< const Ct > overlap_region_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator_pair< const Ct, Layout > overlap_region_range (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Ct >
overlap_region_iterator_pair< const Ct > overlap_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 
template<typename Ct , typename Layout >
overlap_region_iterator_pair< const Ct, Layout > overlap_region_crange (const Ct &container, const typename container_traits< Ct >::key_type &target, const Layout &layout)
 
template<typename Tp >
bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare > make_bounds (const Tp &container, const typename container_traits< Tp >::key_type &lower, const typename container_traits< Tp >::key_type &upper)
 A bounds factory that takes in a container, 2 arguments lower and upper, and returns a fully constructed bounds object. More...
 
template<typename Ct , typename Predicate >
region_iterator< Ct, Predicate > region_end (Ct &container, const Predicate &pred)
 
template<typename Ct , typename Predicate >
region_iterator< const Ct, Predicate > region_end (const Ct &container, const Predicate &pred)
 
template<typename Ct , typename Predicate >
region_iterator< const Ct, Predicate > region_cend (const Ct &container, const Predicate &pred)
 
template<typename Ct >
region_iterator< Ct > region_end (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator< const Ct > region_end (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator< const Ct > region_cend (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct , typename Predicate >
region_iterator< Ct, Predicate > region_begin (Ct &container, const Predicate &pred)
 
template<typename Ct , typename Predicate >
region_iterator< const Ct, Predicate > region_begin (const Ct &container, const Predicate &pred)
 
template<typename Ct , typename Predicate >
region_iterator< const Ct, Predicate > region_cbegin (const Ct &container, const Predicate &pred)
 
template<typename Ct >
region_iterator< Ct > region_begin (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator< const Ct > region_begin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator< const Ct > region_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator_pair< Ct > region_range (Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator_pair< const Ct > region_range (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Ct >
region_iterator_pair< const Ct > region_crange (const Ct &container, const typename container_traits< Ct >::key_type &lower, const typename container_traits< Ct >::key_type &upper)
 
template<typename Container >
equal_iterator_pair< Container > equal_range (Container &container, const typename equal_iterator< Container >::key_type &model)
 Creates a pair of iterator that represent the range of element in the container that are equal to the model given. More...
 
template<typename Container >
equal_iterator_pair< const Container > equal_range (const Container &container, const typename equal_iterator< Container >::key_type &model)
 
template<typename Container >
equal_iterator_pair< const Container > equal_crange (const Container &container, const typename equal_iterator< Container >::key_type &model)
 
template<typename Container >
dimension_type mapping_dimension (const mapping_iterator< Container > &it)
 Return the mapping dimension of the iterator. More...
 
template<typename Container >
void mapping_dimension (mapping_iterator< Container > &it, dimension_type mapping_dim)
 Sets the mapping dimension of the iterator. More...
 
template<typename Container >
mapping_iterator_pair< Container > mapping_range (Container &container, dimension_type mapping_dim)
 Returns a pair of iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
ordered_iterator_pair< Container > ordered_range (Container &container)
 Returns a pair of iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
ordered_iterator< Container > ordered_lower_bound (Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return an iterator pointing to this value. More...
 
template<typename Container >
ordered_iterator< Container > ordered_upper_bound (Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value. More...
 
template<typename Tp , typename Layout >
enclosed_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare, Layout > make_enclosed_bounds (const Tp &container, const typename container_traits< Tp >::key_type &target, Layout tag)
 Enclosed bounds factory that takes in a container, a key and returns an enclosed_bounds type. More...
 
template<typename Tp >
enclosed_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare > make_enclosed_bounds (const Tp &container, const typename container_traits< Tp >::key_type &target)
 Enclosed bounds factory that takes in a container, a key and returns an enclosed_bounds type. More...
 
template<typename Container >
equal_iterator< Container > equal_begin (Container &container, const typename equal_iterator< Container >::key_type &value)
 Find the first element in container that compares equally to value, using container's key_compare comparator. More...
 
template<typename Container >
equal_iterator< const Container > equal_cbegin (const Container &container, const typename equal_iterator< Container >::key_type &value)
 Find the first element in container that compares equally to value, using container's key_compare comparator. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< Ct, double, Diff > euclidian_neighbor_begin (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< const Ct, double, Diff > euclidian_neighbor_begin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< const Ct, double, Diff > euclidian_neighbor_cbegin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< Ct, double > >::type euclidian_neighbor_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< const Ct, double > >::type euclidian_neighbor_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< const Ct, double > >::type euclidian_neighbor_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< Ct, double, Diff > euclidian_neighbor_end (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< const Ct, double, Diff > euclidian_neighbor_end (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator< const Ct, double, Diff > euclidian_neighbor_cend (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< Ct, double > >::type euclidian_neighbor_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< const Ct, double > >::type euclidian_neighbor_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator< const Ct, double > >::type euclidian_neighbor_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a euclidian_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< Ct, DistanceType, Diff > >::type euclidian_neighbor_lower_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< const Ct, DistanceType, Diff > >::type euclidian_neighbor_lower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< const Ct, DistanceType, Diff > >::type euclidian_neighbor_clower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< Ct, DistanceType > >::type euclidian_neighbor_lower_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< const Ct, DistanceType > >::type euclidian_neighbor_lower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< const Ct, DistanceType > >::type euclidian_neighbor_clower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< Ct, DistanceType, Diff > >::type euclidian_neighbor_upper_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< const Ct, DistanceType, Diff > >::type euclidian_neighbor_upper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_floating_point< DistanceType >, euclidian_neighbor_iterator< const Ct, DistanceType, Diff > >::type euclidian_neighbor_cupper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< Ct, DistanceType > >::type euclidian_neighbor_upper_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< const Ct, DistanceType > >::type euclidian_neighbor_upper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_floating_point< DistanceType >::value, euclidian_neighbor_iterator< const Ct, DistanceType > >::type euclidian_neighbor_cupper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair< Ct, double, Diff > euclidian_neighbor_range (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair< const Ct, double, Diff > euclidian_neighbor_range (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair< const Ct, double, Diff > euclidian_neighbor_crange (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator_pair< Ct, double > >::type euclidian_neighbor_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator_pair< const Ct, double > >::type euclidian_neighbor_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, euclidian_neighbor_iterator_pair< const Ct, double > >::type euclidian_neighbor_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< Ct, double, Diff > manhattan_neighbor_begin (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< const Ct, double, Diff > manhattan_neighbor_begin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< const Ct, double, Diff > manhattan_neighbor_cbegin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< Ct, double > >::type manhattan_neighbor_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< const Ct, double > >::type manhattan_neighbor_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< const Ct, double > >::type manhattan_neighbor_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< Ct, double, Diff > manhattan_neighbor_end (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< const Ct, double, Diff > manhattan_neighbor_end (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator< const Ct, double, Diff > manhattan_neighbor_cend (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< Ct, double > >::type manhattan_neighbor_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< const Ct, double > >::type manhattan_neighbor_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator< const Ct, double > >::type manhattan_neighbor_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a manhattan_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< Ct, DistanceType, Diff > >::type manhattan_neighbor_lower_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< const Ct, DistanceType, Diff > >::type manhattan_neighbor_lower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< const Ct, DistanceType, Diff > >::type manhattan_neighbor_clower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< Ct, DistanceType > >::type manhattan_neighbor_lower_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< const Ct, DistanceType > >::type manhattan_neighbor_lower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< const Ct, DistanceType > >::type manhattan_neighbor_clower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< Ct, DistanceType, Diff > >::type manhattan_neighbor_upper_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< const Ct, DistanceType, Diff > >::type manhattan_neighbor_upper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, manhattan_neighbor_iterator< const Ct, DistanceType, Diff > >::type manhattan_neighbor_cupper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< Ct, DistanceType > >::type manhattan_neighbor_upper_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< const Ct, DistanceType > >::type manhattan_neighbor_upper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, manhattan_neighbor_iterator< const Ct, DistanceType > >::type manhattan_neighbor_cupper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair< Ct, double, Diff > manhattan_neighbor_range (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair< const Ct, double, Diff > manhattan_neighbor_range (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair< const Ct, double, Diff > manhattan_neighbor_crange (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator_pair< Ct, double > >::type manhattan_neighbor_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator_pair< const Ct, double > >::type manhattan_neighbor_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, manhattan_neighbor_iterator_pair< const Ct, double > >::type manhattan_neighbor_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Metric >
Metric::distance_type distance (const neighbor_iterator< Ct, Metric > &iter)
 Read/write accessor for neighbor iterators that retrieve the valid calculated distance from the target. More...
 
template<typename Ct , typename Metric >
void distance (neighbor_iterator< Ct, Metric > &iter, const typename Metric::distance_type &distance)
 Read/write accessor for neighbor iterators that retrieve the valid calculated distance from the target. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< Ct, Metric > neighbor_end (Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator with a user-defined Metric. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_end (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator with a user-defined Metric. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_cend (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator with a user-defined Metric. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< Ct > >::type neighbor_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< Ct, Metric > neighbor_begin (Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_begin (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_cbegin (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< Ct > >::type neighbor_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< Ct, Metric > neighbor_lower_bound (Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_lower_bound (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_clower_bound (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< Ct > >::type neighbor_lower_bound (Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_lower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_clower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< Ct, Metric > neighbor_upper_bound (Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_upper_bound (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator< const Ct, Metric > neighbor_cupper_bound (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target, typename Metric::distance_type bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< Ct > >::type neighbor_upper_bound (Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_upper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator< const Ct > >::type neighbor_cupper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, double bound)
 Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound. More...
 
template<typename Ct , typename Metric >
neighbor_iterator_pair< Ct, Metric > neighbor_range (Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Ct , typename Metric >
neighbor_iterator_pair< const Ct, Metric > neighbor_range (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Ct , typename Metric >
neighbor_iterator_pair< const Ct, Metric > neighbor_crange (const Ct &container, const Metric &metric, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator_pair< Ct > >::type neighbor_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator_pair< const Ct > >::type neighbor_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, neighbor_iterator_pair< const Ct > >::type neighbor_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_end (const Container &container)
 Finds the past-the-end position in container for this constant iterator. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_cend (const Container &container)
 Finds the past-the-end position in container for this constant iterator. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_begin (const Container &container)
 Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_cbegin (const Container &container)
 Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim. More...
 
template<typename Tp , typename Layout >
overlap_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare, Layout > make_overlap_bounds (const Tp &container, const typename container_traits< Tp >::key_type &target, Layout tag)
 Overlap bounds factory that takes in a container, a key and returns an overlap_bounds type. More...
 
template<typename Tp >
overlap_bounds< typename container_traits< Tp >::key_type, typename container_traits< Tp >::key_compare > make_overlap_bounds (const Tp &container, const typename container_traits< Tp >::key_type &target)
 Overlap bounds factory that takes in a container, a key and returns an overlap_bounds type. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< Ct, double, Diff > quadrance_neighbor_begin (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< const Ct, double, Diff > quadrance_neighbor_begin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< const Ct, double, Diff > quadrance_neighbor_cbegin (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< Ct, double > >::type quadrance_neighbor_begin (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< const Ct, double > >::type quadrance_neighbor_begin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< const Ct, double > >::type quadrance_neighbor_cbegin (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< Ct, double, Diff > quadrance_neighbor_end (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< const Ct, double, Diff > quadrance_neighbor_end (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator< const Ct, double, Diff > quadrance_neighbor_cend (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< Ct, double > >::type quadrance_neighbor_end (Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< const Ct, double > >::type quadrance_neighbor_end (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator< const Ct, double > >::type quadrance_neighbor_cend (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Returns a quadrance_neighbor_iterator pointing past-the-end. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< Ct, DistanceType, Diff > >::type quadrance_neighbor_lower_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< const Ct, DistanceType, Diff > >::type quadrance_neighbor_lower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< const Ct, DistanceType, Diff > >::type quadrance_neighbor_clower_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< Ct, DistanceType > >::type quadrance_neighbor_lower_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< const Ct, DistanceType > >::type quadrance_neighbor_lower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< const Ct, DistanceType > >::type quadrance_neighbor_clower_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< Ct, DistanceType, Diff > >::type quadrance_neighbor_upper_bound (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< const Ct, DistanceType, Diff > >::type quadrance_neighbor_upper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename Diff , typename DistanceType >
enable_if< import::is_arithmetic< DistanceType >, quadrance_neighbor_iterator< const Ct, DistanceType, Diff > >::type quadrance_neighbor_cupper_bound (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< Ct, DistanceType > >::type quadrance_neighbor_upper_bound (Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< const Ct, DistanceType > >::type quadrance_neighbor_upper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename DistanceType >
enable_if_c< details::is_compare_builtin< Ct >::value &&import::is_arithmetic< DistanceType >::value, quadrance_neighbor_iterator< const Ct, DistanceType > >::type quadrance_neighbor_cupper_bound (const Ct &container, const typename container_traits< Ct >::key_type &target, DistanceType bound)
 Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair< Ct, double, Diff > quadrance_neighbor_range (Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair< const Ct, double, Diff > quadrance_neighbor_range (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair< const Ct, double, Diff > quadrance_neighbor_crange (const Ct &container, const Diff &diff, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator_pair< Ct, double > >::type quadrance_neighbor_range (Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator_pair< const Ct, double > >::type quadrance_neighbor_range (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct >
enable_if< details::is_compare_builtin< Ct >, quadrance_neighbor_iterator_pair< const Ct, double > >::type quadrance_neighbor_crange (const Ct &container, const typename container_traits< Ct >::key_type &target)
 Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target. More...
 
template<typename Ct , typename Predicate >
region_iterator_pair< Ct, Predicate > region_range (Ct &container, const Predicate &pred)
 Returns a spatial::region_iterator_pair where first points to the first element matching the predicate pred in container, and second points after the last element matching pred in container. More...
 
template<typename Ct , typename Predicate >
region_iterator_pair< const Ct, Predicate > region_range (const Ct &container, const Predicate &pred)
 This overload works only on constant containers and will return a set of constant iterators, where the value dereferrenced by the iterator is constant. More...
 
template<typename Ct , typename Predicate >
region_iterator_pair< const Ct, Predicate > region_crange (const Ct &container, const Predicate &pred)
 This overload works only on constant containers and will return a set of constant iterators, where the value dereferrenced by the iterator is constant. More...
 
template<typename Container >
mapping_iterator< Container > mapping_end (Container &container, dimension_type mapping_dim)
 Finds the past-the-end position in container for this constant iterator. More...
 
template<typename Container >
mapping_iterator< const Container > mapping_cend (const Container &container, dimension_type mapping_dim)
 Finds the past-the-end position in container for this constant iterator. More...
 
template<typename Container >
mapping_iterator< Container > mapping_begin (Container &container, dimension_type mapping_dim)
 Finds the value in container for which its key has the smallest coordinate over the dimension mapping_dim. More...
 
template<typename Container >
mapping_iterator< const Container > mapping_cbegin (const Container &container, dimension_type mapping_dim)
 Finds the value in container for which its key has the smallest coordinate over the dimension mapping_dim. More...
 
template<typename Container >
mapping_iterator_pair< const Container > mapping_range (const Container &container, dimension_type mapping_dim)
 Returns a pair of constant iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
mapping_iterator_pair< const Container > mapping_crange (const Container &container, dimension_type mapping_dim)
 Returns a pair of constant iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
mapping_iterator< Container > mapping_lower_bound (Container &container, dimension_type mapping_dim, const typename container_traits< Container >::key_type &bound)
 Finds the value with the smallest coordinate along the mapping dimension that is greater or equal to bound, and return an iterator pointing to this value. More...
 
template<typename Container >
mapping_iterator< const Container > mapping_clower_bound (const Container &container, dimension_type mapping_dim, const typename container_traits< Container >::key_type &bound)
 Finds the value with the smallest coordinate along the mapping dimension that is greater or equal to bound, and return an iterator pointing to this value. More...
 
template<typename Container >
mapping_iterator< Container > mapping_upper_bound (Container &container, dimension_type mapping_dim, const typename container_traits< Container >::key_type &bound)
 Finds the value with the largest coordinate along the mapping dimension that is stricly less than bound, and return an iterator pointing to this value. More...
 
template<typename Container >
mapping_iterator< const Container > mapping_cupper_bound (const Container &container, dimension_type mapping_dim, const typename container_traits< Container >::key_type &bound)
 Finds the value with the largest coordinate along the mapping dimension that is stricly less than bound, and return an iterator pointing to this value. More...
 
template<typename Container >
ordered_iterator_pair< const Container > ordered_range (const Container &container)
 Returns a pair of constant iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
ordered_iterator_pair< const Container > ordered_crange (const Container &container)
 Returns a pair of constant iterator on the first and the last value in the range that can be iterated. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_lower_bound (const Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return a constant iterator to this value. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_clower_bound (const Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return a constant iterator to this value. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_upper_bound (const Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value. More...
 
template<typename Container >
ordered_iterator< const Container > ordered_cupper_bound (const Container &container, const typename container_traits< Container >::key_type &bound)
 Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value. More...
 

Variables

const llhh_layout_tag llhh_layout = llhh_layout_tag()
 This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators. More...
 
const lhlh_layout_tag lhlh_layout = lhlh_layout_tag()
 This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators. More...
 
const hhll_layout_tag hhll_layout = hhll_layout_tag()
 This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators. More...
 
const hlhl_layout_tag hlhl_layout = hlhl_layout_tag()
 This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators. More...
 

Detailed Description

The main namespace used in the library.

All types, functions and variables defined in the library are contained within this namespace. Declaring using spatial in the source of your program gives you access to all features of the library at once.

The main reason to access the spatial namespace is to access one of its containers, such as spatial::point_multiset, spatial::box_multimap, or spatial::idle_point_multiset.

See also
Containers

Class Documentation

struct spatial::container_traits

template<typename Tp>
struct spatial::container_traits< Tp >

The traits type for all containers in the spatial namespace.

Defines all the types that must be published or resolved from the spatial container types.

Definition at line 42 of file traits.hpp.

Class Members
typedef allocator_type allocator_type The allocator used in the container.
typedef const_iterator const_iterator The type used to iterate a constant container.

Every container must have a constant iterator.

typedef const_pointer const_pointer Represent a pointer to a key_type. key_type is always constant.
typedef const_reference const_reference Represent a reference to a key_type. key_type is always constant.
typedef difference_type difference_type The difference type is used when 2 iterators from the tree are substracted.
typedef iterator iterator The type used to iterate a container.

Every container must have an iterator.

typedef key_compare key_compare Comparison functor used to compare two instances of key_type.

It is also the type provided by the user in the various containers, spatial::point_multiset, spatial::box_multiset, spatial::point_multimap or spatial::box_multimap.

typedef key_type key_type The type representing the key managed by the container.

key_type holds the coordinates that keeps its instances ordered in the container.

typedef mode_type mode_type The Link Mode type that is associated with the container.

Accessing this type allows external iterators to tie the nodes in the container with the proper linking type.

typedef pointer pointer Represent a pointer to a value_type.

This type is used by the iterators of the container.

typedef rank_type rank_type The type used to represent the rank of the container.

Either spatial::details::Static_rank or spatial::details::Dynamic_rank. It is not a number but a wrapper around a dimension_type value.

typedef reference reference Represent a reference to a key_type.

May or may not be mutable, depending on the type of key_type.

typedef size_type size_type The size type is used to list the number of element in the tree.
typedef value_compare value_compare Comparison functor used to compare two instances of value_type.

This type is deduced from the key_compare in all containers.

typedef value_type value_type When mapped_type and key_type are different, value_type holds a pair formed by key_type (first) and mapped_type (second); this is the case for spatial::point_multimap or spatial::box_multimap containers.

In spatial::point_multiset and spatial::box_multiset containers, key_type, mapped_type and value_type are all similar types.

struct spatial::enable_if_c

template<bool B, typename Tp = void>
struct spatial::enable_if_c< B, Tp >

If B is true, spatial::enable_if has a public member typedef type, equal to Tp; otherwise, there is no member typedef.

This metafunction is used to conditionally remove functions and classes from overload resolution based on type traits and to provide separate function overloads and specializations for different type traits. spatial::enable_if can be used as an additional function argument (not applicable to operator overloads), as a return type (not applicable to constructors and destructors), or as a class template or function template parameter.

The brief description and the explanation given above are paraphrased from http://en.cppreference.com/w/cpp/types/enable_if

Definition at line 38 of file spatial_check_concept.hpp.

struct spatial::enable_if_c< true, Tp >

template<typename Tp>
struct spatial::enable_if_c< true, Tp >

Definition at line 40 of file spatial_check_concept.hpp.

Class Members
typedef Tp type
struct spatial::hhll_layout_tag

Represents a coordinate layout for the box.

hhll stands for high, high, low, low. This layout means that the upper coordinates of the box are expressed first, and the lower coordinates are expressed after.

For a box of dimension 2, the hhll layout means that for each box, delmited by 2 points x and y, the coordinate are ordered as follow:

B = { x0, x1, y0, y1 }

With x0 >= y0 and x1 >= y1.

Definition at line 126 of file spatial.hpp.

struct spatial::hlhl_layout_tag

Represents a coordinate layout for the box.

lhlh stands for high, low high, low. This layout means that the upper coordinates of the box are expressed first, and the lower coordinates are expressed second, alternatively for each dimension.

For a box of dimension 2, the hlhl layout means that for each box, delmited by 2 points x and y, the coordinate are ordered as follow:

B = { x0, y0, x1, y1 }

With x0 >= y0 and x1 >= y1.

Definition at line 141 of file spatial.hpp.

struct spatial::lhlh_layout_tag

Represents a coordinate layout for the box.

lhlh stands for low, high, low, high. This layout means that the lower coordinates of the box are expressed first, and the higher coordinates are expressed second, alternatively for each dimension.

For a box of dimension 2, the lhlh layout means that for each box, delmited by 2 points x and y, the coordinate are ordered as follow:

B = { x0, y0, x1, y1 }

With x0 <= y0 and x1 <= y1.

Definition at line 112 of file spatial.hpp.

struct spatial::llhh_layout_tag

Represents a coordinate layout for the box.

llhh stands for low, low, high, high. This layout means that the lower coordinates of the box are expressed first, and the higher coordinates are expressed after.

For a box of dimension 2, the llhh layout means that for each box, delmited by 2 points x and y, the coordinate are ordered as follow:

B = { x0, x1, y0, y1 }

With x0 <= y0 and x1 <= y1.

Definition at line 97 of file spatial.hpp.

struct spatial::metric_traits

template<typename Tp>
struct spatial::metric_traits< Tp >

The traits type for all metrics in the spatial namespace.

Defines all the types that must be published or resolved from objects that are a model of Metric.

Template Parameters
TpA model of Metric.

Definition at line 134 of file traits.hpp.

Class Members
typedef distance_type distance_type The type used by the metric to represent distances.

Distance may be user defined in some metric such as spatial::euclidian, spatial::quadrance or spatial::manhattan, but in this case, the type must follow specific rules to the metric, such as overload of specific operators.

struct spatial::mode_traits

template<typename Mode>
struct spatial::mode_traits< Mode >

Definition at line 30 of file traits.hpp.

Class Members
typedef invariant_category invariant_category The invarient category for the linking mode.

Typedef Documentation

typedef std::size_t spatial::dimension_type

Defines the type for the dimension as being a size.

Definition at line 71 of file spatial.hpp.

typedef std::size_t spatial::size_type

Defines a positive integral type for counting objects or storing absolute values.

Definition at line 66 of file spatial.hpp.

typedef std::size_t spatial::weight_type

Defines weight as being a size.

Definition at line 76 of file spatial.hpp.

Enumeration Type Documentation

Defines values for relative ordering.

Enumerator
below 
matching 
above 

Definition at line 81 of file spatial.hpp.

Function Documentation

template<typename Ct >
closed_region_iterator<Ct> spatial::closed_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 239 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator<const Ct> spatial::closed_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 248 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator<const Ct> spatial::closed_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 257 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator<const Ct> spatial::closed_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 230 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator_pair<const Ct> spatial::closed_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 285 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator<Ct> spatial::closed_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 216 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator<const Ct> spatial::closed_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 223 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator_pair<Ct> spatial::closed_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 267 of file spatial_closed_region.hpp.

template<typename Ct >
closed_region_iterator_pair<const Ct> spatial::closed_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 276 of file spatial_closed_region.hpp.

template<typename Iterator >
std::size_t spatial::depth ( const Iterator &  iterator)

Returns the depth of a node's iterator.

The depth of the node is equivalent to the number of parent node crossed on the way to the root node of the tree.

Parameters
iteratorDepth is inspected for this iterator.

Definition at line 84 of file algorithm.hpp.

template<typename Ct , typename Metric >
Metric::distance_type spatial::distance ( const neighbor_iterator< Ct, Metric > &  iter)

Read/write accessor for neighbor iterators that retrieve the valid calculated distance from the target.

The distance read is only relevant if the iterator does not point past-the-end.

Definition at line 539 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
void spatial::distance ( neighbor_iterator< Ct, Metric > &  iter,
const typename Metric::distance_type &  distance 
)

Read/write accessor for neighbor iterators that retrieve the valid calculated distance from the target.

The distance read is only relevant if the iterator does not point past-the-end.

Definition at line 544 of file spatial_neighbor.hpp.

template<typename Ct >
enclosed_region_iterator<Ct> spatial::enclosed_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 344 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<Ct, Layout> spatial::enclosed_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 353 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator<const Ct> spatial::enclosed_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 363 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<const Ct, Layout> spatial::enclosed_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 372 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator<const Ct> spatial::enclosed_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 382 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<const Ct, Layout> spatial::enclosed_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 391 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator<const Ct> spatial::enclosed_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 325 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<const Ct, Layout> spatial::enclosed_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 334 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator_pair<const Ct> spatial::enclosed_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 439 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator_pair<const Ct, Layout> spatial::enclosed_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 448 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator<Ct> spatial::enclosed_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 287 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<Ct, Layout> spatial::enclosed_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 296 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator<const Ct> spatial::enclosed_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 306 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator<const Ct, Layout> spatial::enclosed_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 315 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator_pair<Ct> spatial::enclosed_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 401 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator_pair<Ct, Layout> spatial::enclosed_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 410 of file spatial_enclosed_region.hpp.

template<typename Ct >
enclosed_region_iterator_pair<const Ct> spatial::enclosed_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 420 of file spatial_enclosed_region.hpp.

template<typename Ct , typename Layout >
enclosed_region_iterator_pair<const Ct, Layout> spatial::enclosed_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 429 of file spatial_enclosed_region.hpp.

template<typename Container >
equal_iterator<Container> spatial::equal_begin ( Container &  container,
const typename equal_iterator< Container >::key_type &  value 
)

Find the first element in container that compares equally to value, using container's key_compare comparator.

Template Parameters
ContainerThe container type being iterated.
Parameters
containerThe container being iterated.
valueA value to find matches among other keys stored in the container.

Definition at line 395 of file spatial_equal.hpp.

template<typename Container >
equal_iterator<const Container> spatial::equal_cbegin ( const Container &  container,
const typename equal_iterator< Container >::key_type &  value 
)

Find the first element in container that compares equally to value, using container's key_compare comparator.

Template Parameters
ContainerThe container type being iterated.
Parameters
containerThe container being iterated.
valueA value to find matches among other keys stored in the container.

Definition at line 410 of file spatial_equal.hpp.

template<typename Container >
equal_iterator<const Container> spatial::equal_cend ( const Container &  container,
const typename equal_iterator< Container >::key_type &  value 
)

Definition at line 379 of file spatial_equal.hpp.

template<typename Container >
equal_iterator_pair<const Container> spatial::equal_crange ( const Container &  container,
const typename equal_iterator< Container >::key_type &  model 
)

Definition at line 111 of file equal_iterator.hpp.

template<typename Container >
equal_iterator<Container> spatial::equal_end ( Container &  container,
const typename equal_iterator< Container >::key_type &  value 
)

Definition at line 369 of file spatial_equal.hpp.

template<typename Container >
equal_iterator_pair<Container> spatial::equal_range ( Container &  container,
const typename equal_iterator< Container >::key_type &  model 
)

Creates a pair of iterator that represent the range of element in the container that are equal to the model given.

Template Parameters
ContainerThe type of the container iterated.
Parameters
containerThe container being iterated.
modelThe key to find in container.@(

Definition at line 93 of file equal_iterator.hpp.

template<typename Container >
equal_iterator_pair<const Container> spatial::equal_range ( const Container &  container,
const typename equal_iterator< Container >::key_type &  model 
)

Definition at line 102 of file equal_iterator.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<Ct, double, Diff> spatial::euclidian_neighbor_begin ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_begin(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 194 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<const Ct, double, Diff> spatial::euclidian_neighbor_begin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_begin(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 204 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<Ct, double> >::type spatial::euclidian_neighbor_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 245 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<const Ct, double> >::type spatial::euclidian_neighbor_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 261 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<const Ct, double, Diff> spatial::euclidian_neighbor_cbegin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_begin(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 214 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<const Ct, double> >::type spatial::euclidian_neighbor_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 277 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<const Ct, double, Diff> spatial::euclidian_neighbor_cend ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 331 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<const Ct, double> >::type spatial::euclidian_neighbor_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 394 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_clower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 447 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<const Ct, DistanceType> >::type spatial::euclidian_neighbor_clower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 507 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair<const Ct, double, Diff> spatial::euclidian_neighbor_crange ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= euclidian_neighbor_range(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 676 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator_pair<const Ct, double> >::type spatial::euclidian_neighbor_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in euclidian space, where distances are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= euclidian_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 739 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_cupper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 561 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<const Ct, DistanceType> >::type spatial::euclidian_neighbor_cupper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 621 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<Ct, double, Diff> spatial::euclidian_neighbor_end ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 311 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator<const Ct, double, Diff> spatial::euclidian_neighbor_end ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= euclidian_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 321 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<Ct, double> >::type spatial::euclidian_neighbor_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 362 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator<const Ct, double> >::type spatial::euclidian_neighbor_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a euclidian_neighbor_iterator pointing past-the-end.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator<Ct, float> my_float_nearest_iterator
= euclidian_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 378 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_lower_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 421 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_lower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 434 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<Ct, DistanceType> >::type spatial::euclidian_neighbor_lower_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 471 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<const Ct, DistanceType> >::type spatial::euclidian_neighbor_lower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 489 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair<Ct, double, Diff> spatial::euclidian_neighbor_range ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= euclidian_neighbor_range(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 656 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff >
euclidian_neighbor_iterator_pair<const Ct, double, Diff> spatial::euclidian_neighbor_range ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

The search will occur in euclidian space, where distance are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= euclidian_neighbor_range(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 666 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator_pair<Ct, double> >::type spatial::euclidian_neighbor_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in euclidian space, where distances are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= euclidian_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 707 of file spatial_euclidian_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, euclidian_neighbor_iterator_pair<const Ct, double> >::type spatial::euclidian_neighbor_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in euclidian space, where distances are computed in double, by default. However distances can be expressed in any floating point type by simply assigning the result to an similar iterator using a different distance type:

euclidian_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= euclidian_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 723 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_upper_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 535 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_floating_point<DistanceType>, euclidian_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::euclidian_neighbor_upper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 548 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<Ct, DistanceType> >::type spatial::euclidian_neighbor_upper_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 585 of file spatial_euclidian_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_floating_point<DistanceType>::value, euclidian_neighbor_iterator<const Ct, DistanceType> >::type spatial::euclidian_neighbor_upper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a euclidian_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 603 of file spatial_euclidian_neighbor.hpp.

template<typename Tp >
bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare> spatial::make_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  lower,
const typename container_traits< Tp >::key_type &  upper 
)

A bounds factory that takes in a container, 2 arguments lower and upper, and returns a fully constructed bounds object.

This factory also checks that lower is always less or equal to upper for every dimension. If it is not, it raises invalid_bounds.

Because of this extra check, it is safer to invoke the factory rather than the constructor to build this object, especially if you are expecting user inputs.

Parameters
containerA container to iterate.
lowerA key defining the lower bound of bounds.
upperA key defining the upper bound of bounds.
Returns
a constructed bounds object.
Exceptions
invalid_bounds

Definition at line 112 of file spatial_region.hpp.

template<typename Tp >
closed_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare> spatial::make_closed_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  lower,
const typename container_traits< Tp >::key_type &  upper 
)

A closed_bounds factory that takes in a container, a region defined by lower and upper, and returns a constructed closed_bounds object.

This factory also checks that lower is always less than upper for every dimension. If it is not, it raises invalid_bounds.

Because of this extra check, it is safer to invoke the factory rather than the constructor to build this object, especially if you are expecting user inputs.

Parameters
containerA container to iterate.
lowerA key defining the lower bound of closed_bounds.
upperA key defining the upper bound of closed_bounds.
Returns
a constructed closed_bounds object.
Exceptions
invalid_bounds

Definition at line 107 of file spatial_closed_region.hpp.

template<typename Tp , typename Layout >
enclosed_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare, Layout> spatial::make_enclosed_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  target,
Layout  tag 
)

Enclosed bounds factory that takes in a container, a key and returns an enclosed_bounds type.

This factory also checks that box key is valid, meaning: all its lower coordinates are indeed lower or equal to its higher coordinates.

Definition at line 155 of file spatial_enclosed_region.hpp.

template<typename Tp >
enclosed_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare> spatial::make_enclosed_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  target 
)

Enclosed bounds factory that takes in a container, a key and returns an enclosed_bounds type.

This factory also checks that box key is valid, meaning: all its lower coordinates are indeed lower or equal to its higher coordinates.

Definition at line 170 of file spatial_enclosed_region.hpp.

template<typename Tp >
open_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare> spatial::make_open_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  lower,
const typename container_traits< Tp >::key_type &  upper 
)

A open_bounds factory that takes in a container, a region defined by lower and upper, and returns a constructed open_bounds object.

This factory also checks that lower is always less than upper for every dimension. If it is not, it raises invalid_bounds.

Because of this extra check, it is safer to invoke the factory rather than the constructor to build this object, especially if you are expecting user inputs.

Parameters
containerA container to iterate.
lowerA key defining the lower bound of open_bounds.
upperA key defining the upper bound of open_bounds.
Returns
a constructed open_bounds object.
Exceptions
invalid_bounds

Definition at line 125 of file spatial_open_region.hpp.

template<typename Tp , typename Layout >
overlap_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare, Layout> spatial::make_overlap_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  target,
Layout  tag 
)

Overlap bounds factory that takes in a container, a key and returns an overlap_bounds type.

This factory also checks that box key is valid, meaning: all its lower coordinates are indeed lower or equal to its higher coordinates.

Definition at line 146 of file spatial_overlap_region.hpp.

template<typename Tp >
overlap_bounds<typename container_traits<Tp>::key_type, typename container_traits<Tp>::key_compare> spatial::make_overlap_bounds ( const Tp &  container,
const typename container_traits< Tp >::key_type &  target 
)

Overlap bounds factory that takes in a container, a key and returns an overlap_bounds type.

This factory also checks that box key is valid, meaning: all its lower coordinates are indeed lower or equal to its higher coordinates.

Definition at line 161 of file spatial_overlap_region.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<Ct, double, Diff> spatial::manhattan_neighbor_begin ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_begin(container, diff(), target);

Definition at line 194 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<const Ct, double, Diff> spatial::manhattan_neighbor_begin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_begin(container, diff(), target);

Definition at line 204 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<Ct, double> >::type spatial::manhattan_neighbor_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 245 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<const Ct, double> >::type spatial::manhattan_neighbor_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 261 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<const Ct, double, Diff> spatial::manhattan_neighbor_cbegin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_begin(container, diff(), target);

Definition at line 214 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<const Ct, double> >::type spatial::manhattan_neighbor_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing to the nearest neighbor of target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_begin(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 277 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<const Ct, double, Diff> spatial::manhattan_neighbor_cend ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 331 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<const Ct, double> >::type spatial::manhattan_neighbor_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 394 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_clower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 447 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<const Ct, DistanceType> >::type spatial::manhattan_neighbor_clower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 507 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair<const Ct, double, Diff> spatial::manhattan_neighbor_crange ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= manhattan_neighbor_range(container, diff(), target);

Definition at line 676 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator_pair<const Ct, double> >::type spatial::manhattan_neighbor_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= manhattan_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 739 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_cupper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 561 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<const Ct, DistanceType> >::type spatial::manhattan_neighbor_cupper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 621 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<Ct, double, Diff> spatial::manhattan_neighbor_end ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 311 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator<const Ct, double, Diff> spatial::manhattan_neighbor_end ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= manhattan_neighbor_end(container, diff(), target);
Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

Definition at line 321 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<Ct, double> >::type spatial::manhattan_neighbor_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 362 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator<const Ct, double> >::type spatial::manhattan_neighbor_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a manhattan_neighbor_iterator pointing past-the-end.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator<Ct, float> my_float_nearest_iterator
= manhattan_neighbor_end(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 378 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_lower_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 421 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_lower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 434 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<Ct, DistanceType> >::type spatial::manhattan_neighbor_lower_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 471 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<const Ct, DistanceType> >::type spatial::manhattan_neighbor_lower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 489 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair<Ct, double, Diff> spatial::manhattan_neighbor_range ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= manhattan_neighbor_range(container, diff(), target);

Definition at line 656 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff >
manhattan_neighbor_iterator_pair<const Ct, double, Diff> spatial::manhattan_neighbor_range ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= manhattan_neighbor_range(container, diff(), target);

Definition at line 666 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator_pair<Ct, double> >::type spatial::manhattan_neighbor_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= manhattan_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 707 of file spatial_manhattan_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, manhattan_neighbor_iterator_pair<const Ct, double> >::type spatial::manhattan_neighbor_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in manhattan space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

manhattan_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= manhattan_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 723 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_upper_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 535 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::manhattan_neighbor_upper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 548 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<Ct, DistanceType> >::type spatial::manhattan_neighbor_upper_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 585 of file spatial_manhattan_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, manhattan_neighbor_iterator<const Ct, DistanceType> >::type spatial::manhattan_neighbor_upper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a manhattan_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 603 of file spatial_manhattan_neighbor.hpp.

template<typename Container >
mapping_iterator<Container> spatial::mapping_begin ( Container &  container,
dimension_type  mapping_dim 
)

Finds the value in container for which its key has the smallest coordinate over the dimension mapping_dim.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 481 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<const Container> spatial::mapping_cbegin ( const Container &  container,
dimension_type  mapping_dim 
)

Finds the value in container for which its key has the smallest coordinate over the dimension mapping_dim.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 497 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<const Container> spatial::mapping_cend ( const Container &  container,
dimension_type  mapping_dim 
)

Finds the past-the-end position in container for this constant iterator.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has guarenteed constant time complexity: $O(1)\,$

Definition at line 454 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<const Container> spatial::mapping_clower_bound ( const Container &  container,
dimension_type  mapping_dim,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the smallest coordinate along the mapping dimension that is greater or equal to bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along mapping_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 698 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator_pair<const Container> spatial::mapping_crange ( const Container &  container,
dimension_type  mapping_dim 
)

Returns a pair of constant iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling mapping_begin() and mapping_end() on both iterators.

To combine it with std::tie, use it this way:

mapping<pointset<2, int> >::iterator it, end;
std::tie(it, end) = mapping_range(0, my_points);
for(; it != end; ++it)
{
// ...
}

Notice that an iterator type is declared, and not an iterator_pair type.

Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 645 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<const Container> spatial::mapping_cupper_bound ( const Container &  container,
dimension_type  mapping_dim,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the largest coordinate along the mapping dimension that is stricly less than bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along mapping_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 748 of file mapping_iterator.hpp.

template<typename Container >
dimension_type spatial::mapping_dimension ( const mapping_iterator< Container > &  it)

Return the mapping dimension of the iterator.

Parameters
itthe iterator where the mapping dimension is retreived.

Definition at line 402 of file mapping_iterator.hpp.

template<typename Container >
void spatial::mapping_dimension ( mapping_iterator< Container > &  it,
dimension_type  mapping_dim 
)

Sets the mapping dimension of the iterator.

Parameters
itThe iterator where the mapping dimension is set.
mapping_dimThe new mapping dimension to use.

Definition at line 412 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<Container> spatial::mapping_end ( Container &  container,
dimension_type  mapping_dim 
)

Finds the past-the-end position in container for this constant iterator.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has guarenteed constant time complexity: $O(1)\,$

Definition at line 444 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<Container> spatial::mapping_lower_bound ( Container &  container,
dimension_type  mapping_dim,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the smallest coordinate along the mapping dimension that is greater or equal to bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along mapping_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 680 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator_pair<Container> spatial::mapping_range ( Container &  container,
dimension_type  mapping_dim 
)

Returns a pair of iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling mapping_begin() and mapping_end() on both iterators.

To combine it with std::tie, use it this way:

mapping<pointset<2, int> >::iterator it, end;
std::tie(it, end) = mapping_range(0, my_points);
for(; it != end; ++it)
{
// ...
}

Notice that an iterator type is declared, and not an iterator_pair type.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 596 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator_pair<const Container> spatial::mapping_range ( const Container &  container,
dimension_type  mapping_dim 
)

Returns a pair of constant iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling mapping_begin() and mapping_end() on both iterators.

To combine it with std::tie, use it this way:

mapping<pointset<2, int> >::iterator it, end;
std::tie(it, end) = mapping_range(0, my_points);
for(; it != end; ++it)
{
// ...
}

Notice that an iterator type is declared, and not an iterator_pair type.

Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 636 of file mapping_iterator.hpp.

template<typename Container >
mapping_iterator<Container> spatial::mapping_upper_bound ( Container &  container,
dimension_type  mapping_dim,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the largest coordinate along the mapping dimension that is stricly less than bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
mapping_dimThe dimension that is the reference for the iteration: all iterated values will be ordered along this dimension, from smallest to largest.
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along mapping_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 731 of file mapping_iterator.hpp.

template<typename Container >
std::pair<std::size_t> spatial::minmax_depth ( const Container &  container)

Returns a pair containing the minimum (as first) and maximum (as second) depth found in the container's tree.

The maximum depth of a tree returns the number of nodes along the longest path from the root node of the tree to any leaf node. On the contrary, the minimum depth of a tree returns the number of nodes along the shortest path from the root node of the tree to any leaf node. If the tree is empty, the minimum and the maximum depth are equal to 0, therefore.

Parameters
containerMin and max depth are inspected in this container.

Definition at line 39 of file algorithm.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<Ct, Metric> spatial::neighbor_begin ( Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 723 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_begin ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 739 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<Ct> >::type spatial::neighbor_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 772 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 786 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_cbegin ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target using a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 755 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a neighbor_iterator pointing to the nearest neighbor of target assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 800 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_cend ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator with a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 654 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 701 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_clower_bound ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 859 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_clower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 910 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator_pair<const Ct, Metric> spatial::neighbor_crange ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 1066 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator_pair<const Ct> >::type spatial::neighbor_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 1109 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_cupper_bound ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 970 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_cupper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance to the target.

Definition at line 1021 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<Ct, Metric> spatial::neighbor_end ( Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator with a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 634 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_end ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator with a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 644 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<Ct> >::type spatial::neighbor_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 673 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Build a past-the-end neighbor iterator, assuming an euclidian metric with distances expressed in double.

It requires that the container used was defined with a built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 687 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<Ct, Metric> spatial::neighbor_lower_bound ( Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 825 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_lower_bound ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 842 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<Ct> >::type spatial::neighbor_lower_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 880 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_lower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater or equal to the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 895 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator_pair<Ct, Metric> spatial::neighbor_range ( Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 1046 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator_pair<const Ct, Metric> spatial::neighbor_range ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.

Definition at line 1056 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator_pair<Ct> >::type spatial::neighbor_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 1089 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator_pair<const Ct> >::type spatial::neighbor_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a neighbor_iterator_pair representing the range of values from the closest to the furthest in the container iterated.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.

Definition at line 1099 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<Ct, Metric> spatial::neighbor_upper_bound ( Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 936 of file spatial_neighbor.hpp.

template<typename Ct , typename Metric >
neighbor_iterator<const Ct, Metric> spatial::neighbor_upper_bound ( const Ct &  container,
const Metric &  metric,
const typename container_traits< Ct >::key_type &  target,
typename Metric::distance_type  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is strictly greater than the value given in bound.

Uses a user-defined Metric.

Parameters
containerThe container in which a neighbor must be found.
metricThe metric to use in search of the neighbor.
targetThe target key used in the neighbor search.
boundThe minimum distance from the target.

Definition at line 953 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<Ct> >::type spatial::neighbor_upper_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance to the target.

Definition at line 991 of file spatial_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, neighbor_iterator<const Ct> >::type spatial::neighbor_upper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
double  bound 
)

Build a neighbor_iterator pointing to the neighbor closest to target but for which distance to target is greater than the value given in bound.

It assumes an euclidian metric with distances expressed in double. It also requires that the container used was defined with one of the built-in key compare functor.

Parameters
containerThe container in which a neighbor must be found.
targetThe target key used in the neighbor search.
boundThe minimum distance to the target.

Definition at line 1006 of file spatial_neighbor.hpp.

template<typename Ct >
open_region_iterator<Ct> spatial::open_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 256 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator<const Ct> spatial::open_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 263 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator<const Ct> spatial::open_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 270 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator<const Ct> spatial::open_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 249 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator_pair<const Ct> spatial::open_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 293 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator<Ct> spatial::open_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 235 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator<const Ct> spatial::open_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 242 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator_pair<Ct> spatial::open_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 279 of file spatial_open_region.hpp.

template<typename Ct >
open_region_iterator_pair<const Ct> spatial::open_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 286 of file spatial_open_region.hpp.

template<typename Container >
ordered_iterator<Container> spatial::ordered_begin ( Container &  container)

Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$
Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).

Definition at line 407 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_begin ( const Container &  container)

Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 429 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_cbegin ( const Container &  container)

Finds the value in container for which its key has the smallest coordinate over the dimension ordered_dim.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 439 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_cend ( const Container &  container)

Finds the past-the-end position in container for this constant iterator.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has guarenteed constant time complexity: $O(1)\,$

Definition at line 384 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_clower_bound ( const Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return a constant iterator to this value.

Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 258 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator_pair<const Container> spatial::ordered_crange ( const Container &  container)

Returns a pair of constant iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling ordered_begin() and ordered_end() on both iterators.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 128 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_cupper_bound ( const Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value.

Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$
See also
ordered_iterator

Definition at line 329 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator<Container> spatial::ordered_end ( Container &  container)

Finds the past-the-end position in container for this constant iterator.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has guarenteed constant time complexity: $O(1)\,$
Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).

Definition at line 352 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_end ( const Container &  container)

Finds the past-the-end position in container for this constant iterator.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has guarenteed constant time complexity: $O(1)\,$

Definition at line 375 of file spatial_ordered.hpp.

template<typename Container >
ordered_iterator<Container> spatial::ordered_lower_bound ( Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 217 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_lower_bound ( const Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the smallest coordinate along the ordered dimension that is greater or equal to bound, and return a constant iterator to this value.

Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 246 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator_pair<Container> spatial::ordered_range ( Container &  container)

Returns a pair of iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling ordered_begin() and ordered_end() on both iterators.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 96 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator_pair<const Container> spatial::ordered_range ( const Container &  container)

Returns a pair of constant iterator on the first and the last value in the range that can be iterated.

This function is convenient to use with std::tie, and is equivalent to calling ordered_begin() and ordered_end() on both iterators.

Template Parameters
ContainerThe type of container to iterate.
Parameters
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the past-the-end position in the container.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$

Definition at line 120 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator<Container> spatial::ordered_upper_bound ( Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value.

Attention
This iterator impose constness constraints on its value_type if the container's is a set and not a map. Iterators on sets prevent modification of the value_type because modifying the key may result in invalidation of the tree. If the container is a map, only the mapped_type can be modified (the second element).
Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$
See also
ordered_iterator

Definition at line 288 of file ordered_iterator.hpp.

template<typename Container >
ordered_iterator<const Container> spatial::ordered_upper_bound ( const Container &  container,
const typename container_traits< Container >::key_type &  bound 
)

Finds the value with the largest coordinate along the ordered dimension that is stricly less than bound, and return an iterator pointing to this value.

Template Parameters
ContainerThe type of container to iterate.
Parameters
boundThe lowest bound to the iterator position.
containerThe container to iterate.
Exceptions
invalid_dimensionIf the dimension specified is larger than the dimension from the rank of the container.
Returns
An iterator pointing to the value with the smallest coordinate greater or equal to bound along ordered_dim.
Complexity:
This function has average fractional time complexity: $O(n^{1\,-\,1/d})\,$
See also
ordered_iterator

Definition at line 317 of file ordered_iterator.hpp.

template<typename Ct >
overlap_region_iterator<Ct> spatial::overlap_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 339 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<Ct, Layout> spatial::overlap_region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 348 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator<const Ct> spatial::overlap_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 358 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<const Ct, Layout> spatial::overlap_region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 367 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator<const Ct> spatial::overlap_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 377 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<const Ct, Layout> spatial::overlap_region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 386 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator<const Ct> spatial::overlap_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 320 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<const Ct, Layout> spatial::overlap_region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 329 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator_pair<const Ct> spatial::overlap_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 434 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator_pair<const Ct, Layout> spatial::overlap_region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 443 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator<Ct> spatial::overlap_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 282 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<Ct, Layout> spatial::overlap_region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 291 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator<const Ct> spatial::overlap_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 301 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator<const Ct, Layout> spatial::overlap_region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 310 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator_pair<Ct> spatial::overlap_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 396 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator_pair<Ct, Layout> spatial::overlap_region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 405 of file spatial_overlap_region.hpp.

template<typename Ct >
overlap_region_iterator_pair<const Ct> spatial::overlap_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Definition at line 415 of file spatial_overlap_region.hpp.

template<typename Ct , typename Layout >
overlap_region_iterator_pair<const Ct, Layout> spatial::overlap_region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
const Layout &  layout 
)

Definition at line 424 of file spatial_overlap_region.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<Ct, double, Diff> spatial::quadrance_neighbor_begin ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 194 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<const Ct, double, Diff> spatial::quadrance_neighbor_begin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 204 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<Ct, double> >::type spatial::quadrance_neighbor_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 245 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<const Ct, double> >::type spatial::quadrance_neighbor_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 261 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<const Ct, double, Diff> spatial::quadrance_neighbor_cbegin ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 214 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<const Ct, double> >::type spatial::quadrance_neighbor_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing to the nearest neighbor of target.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_begin(container, diff(), target);

Definition at line 277 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<const Ct, double, Diff> spatial::quadrance_neighbor_cend ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 331 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<const Ct, double> >::type spatial::quadrance_neighbor_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 394 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_clower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 447 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<const Ct, DistanceType> >::type spatial::quadrance_neighbor_clower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 507 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair<const Ct, double, Diff> spatial::quadrance_neighbor_crange ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= quadrance_neighbor_range(container, diff(), target);

Definition at line 676 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator_pair<const Ct, double> >::type spatial::quadrance_neighbor_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= quadrance_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 739 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_cupper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 561 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<const Ct, DistanceType> >::type spatial::quadrance_neighbor_cupper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 621 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<Ct, double, Diff> spatial::quadrance_neighbor_end ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 311 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator<const Ct, double, Diff> spatial::quadrance_neighbor_end ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 321 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<Ct, double> >::type spatial::quadrance_neighbor_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 362 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator<const Ct, double> >::type spatial::quadrance_neighbor_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Returns a quadrance_neighbor_iterator pointing past-the-end.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator<Ct, float, Diff> my_float_nearest_iterator
= quadrance_neighbor_end(container, diff(), target);

Definition at line 378 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_lower_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 421 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_lower_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 434 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<Ct, DistanceType> >::type spatial::quadrance_neighbor_lower_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 471 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<const Ct, DistanceType> >::type spatial::quadrance_neighbor_lower_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is a least as far as bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 489 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair<Ct, double, Diff> spatial::quadrance_neighbor_range ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= quadrance_neighbor_range(container, diff(), target);

Definition at line 656 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff >
quadrance_neighbor_iterator_pair<const Ct, double, Diff> spatial::quadrance_neighbor_range ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable element in container from the closest to the furthest to target.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float, Diff> my_float_iterator_pair
= quadrance_neighbor_range(container, diff(), target);

Definition at line 666 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator_pair<Ct, double> >::type spatial::quadrance_neighbor_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= quadrance_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 707 of file spatial_quadrance_neighbor.hpp.

template<typename Ct >
enable_if<details::is_compare_builtin<Ct>, quadrance_neighbor_iterator_pair<const Ct, double> >::type spatial::quadrance_neighbor_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target 
)

Make a pair of iterators spanning the range of iterable elements in container from the closest to the furthest to target.

The search will occur in quadrance space, where distance are computed in double, by default. However distances can be expressed in any arithmetic type by simply assigning the result to an similar iterator using a different distance type:

quadrance_neighbor_iterator_pair<Ct, float> my_float_iterator_pair
= quadrance_neighbor_range(container, target);
Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.

Definition at line 723 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_upper_bound ( Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 535 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Diff , typename DistanceType >
enable_if<import::is_arithmetic<DistanceType>, quadrance_neighbor_iterator<const Ct, DistanceType, Diff> >::type spatial::quadrance_neighbor_upper_bound ( const Ct &  container,
const Diff &  diff,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that further than bound.

Parameters
containerThe container to iterate.
diffA model of Difference.
targetSearch for element in container closest to target.
boundThe minimum distance at which a neighbor should be found.

Definition at line 548 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<Ct, DistanceType> >::type spatial::quadrance_neighbor_upper_bound ( Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 585 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename DistanceType >
enable_if_c<details::is_compare_builtin<Ct>::value && import::is_arithmetic<DistanceType>::value, quadrance_neighbor_iterator<const Ct, DistanceType> >::type spatial::quadrance_neighbor_upper_bound ( const Ct &  container,
const typename container_traits< Ct >::key_type &  target,
DistanceType  bound 
)

Returns a quadrance_neighbor_iterator pointing to the closest element to target that is further than bound.

Parameters
containerThe container to iterate.
targetSearch for element in container closest to target.
boundThe minimum distance at which an element should be found.

Definition at line 603 of file spatial_quadrance_neighbor.hpp.

template<typename Ct , typename Predicate >
region_iterator<Ct, Predicate> spatial::region_begin ( Ct &  container,
const Predicate &  pred 
)

Definition at line 449 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator<const Ct, Predicate> spatial::region_begin ( const Ct &  container,
const Predicate &  pred 
)

Definition at line 459 of file spatial_region.hpp.

template<typename Ct >
region_iterator<Ct> spatial::region_begin ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 474 of file spatial_region.hpp.

template<typename Ct >
region_iterator<const Ct> spatial::region_begin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 481 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator<const Ct, Predicate> spatial::region_cbegin ( const Ct &  container,
const Predicate &  pred 
)

Definition at line 469 of file spatial_region.hpp.

template<typename Ct >
region_iterator<const Ct> spatial::region_cbegin ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 488 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator<const Ct, Predicate> spatial::region_cend ( const Ct &  container,
const Predicate &  pred 
)

Definition at line 423 of file spatial_region.hpp.

template<typename Ct >
region_iterator<const Ct> spatial::region_cend ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 442 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator_pair<const Ct, Predicate> spatial::region_crange ( const Ct &  container,
const Predicate &  pred 
)

This overload works only on constant containers and will return a set of constant iterators, where the value dereferrenced by the iterator is constant.

Definition at line 592 of file spatial_region.hpp.

template<typename Ct >
region_iterator_pair<const Ct> spatial::region_crange ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 615 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator<Ct, Predicate> spatial::region_end ( Ct &  container,
const Predicate &  pred 
)

Definition at line 405 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator<const Ct, Predicate> spatial::region_end ( const Ct &  container,
const Predicate &  pred 
)

Definition at line 414 of file spatial_region.hpp.

template<typename Ct >
region_iterator<Ct> spatial::region_end ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 428 of file spatial_region.hpp.

template<typename Ct >
region_iterator<const Ct> spatial::region_end ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 435 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator_pair<Ct, Predicate> spatial::region_range ( Ct &  container,
const Predicate &  pred 
)

Returns a spatial::region_iterator_pair where first points to the first element matching the predicate pred in container, and second points after the last element matching pred in container.

Template Parameters
CtThe type of container.
PredicateThe type of pred, which must be a model of Region Predicate.
Parameters
containerThe container being searched.
predThe predicate used for the search.

Definition at line 570 of file spatial_region.hpp.

template<typename Ct , typename Predicate >
region_iterator_pair<const Ct, Predicate> spatial::region_range ( const Ct &  container,
const Predicate &  pred 
)

This overload works only on constant containers and will return a set of constant iterators, where the value dereferrenced by the iterator is constant.

Definition at line 581 of file spatial_region.hpp.

template<typename Ct >
region_iterator_pair<Ct> spatial::region_range ( Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 601 of file spatial_region.hpp.

template<typename Ct >
region_iterator_pair<const Ct> spatial::region_range ( const Ct &  container,
const typename container_traits< Ct >::key_type &  lower,
const typename container_traits< Ct >::key_type &  upper 
)

Definition at line 608 of file spatial_region.hpp.

template<typename Ct , typename Metric >
const container_traits<Ct>::key_type& spatial::target_key ( const neighbor_iterator< Ct, Metric > &  iter)

A quick accessor for neighbor iterators that retrive the key that is the target for the nearest neighbor iteration.

Definition at line 555 of file spatial_neighbor.hpp.

Variable Documentation

const hhll_layout_tag spatial::hhll_layout = hhll_layout_tag()

This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators.

Creation of these iterators is facilitated by these objects.

Warning
This constant is unique for each translation unit, and therefore its address will differ for each translation unit.

Definition at line 155 of file spatial.hpp.

const hlhl_layout_tag spatial::hlhl_layout = hlhl_layout_tag()

This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators.

Creation of these iterators is facilitated by these objects.

Warning
This constant is unique for each translation unit, and therefore its address will differ for each translation unit.

Definition at line 156 of file spatial.hpp.

const lhlh_layout_tag spatial::lhlh_layout = lhlh_layout_tag()

This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators.

Creation of these iterators is facilitated by these objects.

Warning
This constant is unique for each translation unit, and therefore its address will differ for each translation unit.

Definition at line 154 of file spatial.hpp.

const llhh_layout_tag spatial::llhh_layout = llhh_layout_tag()

This constant is used to declare a type layout tag, which is required by the overlap and enclosed region iterators.

Creation of these iterators is facilitated by these objects.

Warning
This constant is unique for each translation unit, and therefore its address will differ for each translation unit.

Definition at line 153 of file spatial.hpp.