Spatial C++ Library
Generic Multi-Dimensional Containers and Spatial Operations
spatial_manhattan_neighbor.hpp
1 // -*- C++ -*-
2 //
3 // Copyright Sylvain Bougerel 2009 - 2013.
4 // Distributed under the Boost Software License, Version 1.0.
5 // (See accompanying file COPYING or copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7 
17 #ifndef SPATIAL_MANHATTAN_NEIGHBOR_HPP
18 #define SPATIAL_MANHATTAN_NEIGHBOR_HPP
19 
20 #include "spatial_neighbor.hpp"
21 
22 namespace spatial
23 {
39  template <typename Ct, typename DistanceType, typename Diff
41  = typename details::with_builtin_difference<Ct>::type>
42  class manhattan_neighbor_iterator
43  : public neighbor_iterator<Ct, manhattan<Ct, DistanceType, Diff> >
44  {
45  // Check that DistanceType is a fundamental arithmetic type
46  typedef typename enable_if<import::is_arithmetic<DistanceType> >::type
47  check_concept_distance_type_is_arithmetic;
48 
49  public:
50  manhattan_neighbor_iterator() { }
51 
52  template <typename AnyDistanceType>
53  manhattan_neighbor_iterator
54  (const neighbor_iterator
55  <Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
56  : neighbor_iterator<Ct, manhattan<Ct, DistanceType, Diff> >
57  (other.rank(), other.key_comp(), other.metric(),
58  other.target_key(), other.node_dim, other.node,
59  static_cast<AnyDistanceType>(other.distance())) { }
60  };
61 
62  template <typename Ct, typename DistanceType, typename Diff>
63  class manhattan_neighbor_iterator<const Ct, DistanceType, Diff>
64  : public neighbor_iterator<const Ct, manhattan<Ct, DistanceType, Diff> >
65  {
66  // Some concept checking performed here
67  typedef enable_if<import::is_arithmetic<DistanceType> >
68  check_concept_distance_type_is_arithmetic;
69 
70  public:
71  manhattan_neighbor_iterator() { }
72 
73  template <typename AnyDistanceType>
74  manhattan_neighbor_iterator
75  (const neighbor_iterator
76  <const Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
77  : neighbor_iterator<const Ct, manhattan<Ct, DistanceType, Diff> >
78  (other.rank(), other.key_comp(), other.metric(),
79  other.target_key(), other.node_dim, other.node,
80  static_cast<AnyDistanceType>(other.distance())) { }
81 
82  template <typename AnyDistanceType>
83  manhattan_neighbor_iterator
84  (const neighbor_iterator
85  <Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
86  : neighbor_iterator<const Ct, manhattan<Ct, DistanceType, Diff> >
87  (other.rank(), other.key_comp(), other.metric(),
88  other.target_key(), other.node_dim, other.node,
89  static_cast<AnyDistanceType>(other.distance())) { }
90  };
92 
108  template <typename Ct, typename DistanceType, typename Diff
110  = typename details::with_builtin_difference<Ct>::type>
111  class manhattan_neighbor_iterator_pair
112  : public neighbor_iterator_pair<Ct, manhattan<Ct, DistanceType, Diff> >
113  {
114  // Some concept checking performed here
115  typedef enable_if<import::is_arithmetic<DistanceType> >
116  check_concept_distance_type_is_arithmetic;
117 
118  public:
119  manhattan_neighbor_iterator_pair() { }
120 
121  manhattan_neighbor_iterator_pair
122  (const manhattan_neighbor_iterator<Ct, DistanceType, Diff>& a,
123  const manhattan_neighbor_iterator<Ct, DistanceType, Diff>& b)
124  : neighbor_iterator_pair<Ct, manhattan<Ct, DistanceType, Diff> >
125  (a, b) { }
126 
127  template <typename AnyDistanceType>
128  manhattan_neighbor_iterator_pair
129  (const neighbor_iterator_pair
130  <Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
131  : neighbor_iterator_pair<Ct, manhattan<Ct, DistanceType, Diff> >
132  (manhattan_neighbor_iterator_pair<Ct, DistanceType, Diff>
133  (other.first, other.second)) { }
134  };
135 
136  template <typename Ct, typename DistanceType, typename Diff>
137  class manhattan_neighbor_iterator_pair<const Ct, DistanceType, Diff>
138  : public neighbor_iterator_pair
139  <const Ct, manhattan<Ct, DistanceType, Diff> >
140  {
141  // Some concept checking performed here
142  typedef enable_if<import::is_arithmetic<DistanceType> >
143  check_concept_distance_type_is_arithmetic;
144 
145  public:
146  manhattan_neighbor_iterator_pair() { }
147 
148  manhattan_neighbor_iterator_pair
149  (const manhattan_neighbor_iterator<const Ct, DistanceType, Diff>& a,
150  const manhattan_neighbor_iterator<const Ct, DistanceType, Diff>& b)
151  : neighbor_iterator_pair<const Ct, manhattan<Ct, DistanceType, Diff> >
152  (a, b) { }
153 
154  template <typename AnyDistanceType>
155  manhattan_neighbor_iterator_pair
156  (const neighbor_iterator_pair
157  <const Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
158  : neighbor_iterator_pair<const Ct, manhattan<Ct, DistanceType, Diff> >
159  (manhattan_neighbor_iterator_pair<const Ct, DistanceType, Diff>
160  (other.first, other.second)) { }
161 
162  template <typename AnyDistanceType>
163  manhattan_neighbor_iterator_pair
164  (const neighbor_iterator_pair
165  <Ct, manhattan<Ct, AnyDistanceType, Diff> >& other)
166  : neighbor_iterator_pair<const Ct, manhattan<Ct, DistanceType, Diff> >
167  (manhattan_neighbor_iterator_pair<const Ct, DistanceType, Diff>
168  (other.first, other.second)) { }
169  };
171 
190  template <typename Ct, typename Diff>
192  inline manhattan_neighbor_iterator<Ct, double, Diff>
193  manhattan_neighbor_begin
194  (Ct& container, const Diff& diff,
195  const typename container_traits<Ct>::key_type& target)
196  {
197  return neighbor_begin
198  (container, manhattan<Ct, double, Diff>(diff), target);
199  }
200 
201  template <typename Ct, typename Diff>
202  inline manhattan_neighbor_iterator<const Ct, double, Diff>
203  manhattan_neighbor_begin
204  (const Ct& container, const Diff& diff,
205  const typename container_traits<Ct>::key_type& target)
206  {
207  return neighbor_begin
208  (container, manhattan<Ct, double, Diff>(diff), target);
209  }
210 
211  template <typename Ct, typename Diff>
212  inline manhattan_neighbor_iterator<const Ct, double, Diff>
213  manhattan_neighbor_cbegin
214  (const Ct& container, const Diff& diff,
215  const typename container_traits<Ct>::key_type& target)
216  {
217  return neighbor_begin
218  (container, manhattan<Ct, double, Diff>(diff), target);
219  }
221 
239  template <typename Ct>
241  inline typename
242  enable_if<details::is_compare_builtin<Ct>,
243  manhattan_neighbor_iterator<Ct, double> >::type
244  manhattan_neighbor_begin
245  (Ct& container,
246  const typename container_traits<Ct>::key_type& target)
247  {
248  return neighbor_begin
249  (container,
250  manhattan<Ct, double,
251  typename details::with_builtin_difference<Ct>::type>
252  (details::with_builtin_difference<Ct>()(container)),
253  target);
254  }
255 
256  template <typename Ct>
257  inline typename
258  enable_if<details::is_compare_builtin<Ct>,
259  manhattan_neighbor_iterator<const Ct, double> >::type
260  manhattan_neighbor_begin
261  (const Ct& container,
262  const typename container_traits<Ct>::key_type& target)
263  {
264  return neighbor_begin
265  (container,
266  manhattan<Ct, double,
267  typename details::with_builtin_difference<Ct>::type>
268  (details::with_builtin_difference<Ct>()(container)),
269  target);
270  }
271 
272  template <typename Ct>
273  inline typename
274  enable_if<details::is_compare_builtin<Ct>,
275  manhattan_neighbor_iterator<const Ct, double> >::type
276  manhattan_neighbor_cbegin
277  (const Ct& container,
278  const typename container_traits<Ct>::key_type& target)
279  {
280  return neighbor_begin
281  (container,
282  manhattan<Ct, double,
283  typename details::with_builtin_difference<Ct>::type>
284  (details::with_builtin_difference<Ct>()(container)),
285  target);
286  }
288 
307  template <typename Ct, typename Diff>
309  inline manhattan_neighbor_iterator<Ct, double, Diff>
310  manhattan_neighbor_end
311  (Ct& container, const Diff& diff,
312  const typename container_traits<Ct>::key_type& target)
313  {
314  return neighbor_end
315  (container, manhattan<Ct, double, Diff>(diff), target);
316  }
317 
318  template <typename Ct, typename Diff>
319  inline manhattan_neighbor_iterator<const Ct, double, Diff>
320  manhattan_neighbor_end
321  (const Ct& container, const Diff& diff,
322  const typename container_traits<Ct>::key_type& target)
323  {
324  return neighbor_end
325  (container, manhattan<Ct, double, Diff>(diff), target);
326  }
327 
328  template <typename Ct, typename Diff>
329  inline manhattan_neighbor_iterator<const Ct, double, Diff>
330  manhattan_neighbor_cend
331  (const Ct& container, const Diff& diff,
332  const typename container_traits<Ct>::key_type& target)
333  {
334  return neighbor_end
335  (container, manhattan<Ct, double, Diff>(diff), target);
336  }
338 
356  template <typename Ct>
358  inline typename
359  enable_if<details::is_compare_builtin<Ct>,
360  manhattan_neighbor_iterator<Ct, double> >::type
361  manhattan_neighbor_end
362  (Ct& container,
363  const typename container_traits<Ct>::key_type& target)
364  {
365  return neighbor_end
366  (container,
367  manhattan<Ct, double,
368  typename details::with_builtin_difference<Ct>::type>
369  (details::with_builtin_difference<Ct>()(container)),
370  target);
371  }
372 
373  template <typename Ct>
374  inline typename
375  enable_if<details::is_compare_builtin<Ct>,
376  manhattan_neighbor_iterator<const Ct, double> >::type
377  manhattan_neighbor_end
378  (const Ct& container,
379  const typename container_traits<Ct>::key_type& target)
380  {
381  return neighbor_end
382  (container,
383  manhattan<Ct, double,
384  typename details::with_builtin_difference<Ct>::type>
385  (details::with_builtin_difference<Ct>()(container)),
386  target);
387  }
388 
389  template <typename Ct>
390  inline typename
391  enable_if<details::is_compare_builtin<Ct>,
392  manhattan_neighbor_iterator<const Ct, double> >::type
393  manhattan_neighbor_cend
394  (const Ct& container,
395  const typename container_traits<Ct>::key_type& target)
396  {
397  return neighbor_end
398  (container,
399  manhattan<Ct, double,
400  typename details::with_builtin_difference<Ct>::type>
401  (details::with_builtin_difference<Ct>()(container)),
402  target);
403  }
405 
415  template <typename Ct, typename Diff, typename DistanceType>
417  inline typename
418  enable_if<import::is_arithmetic<DistanceType>,
419  manhattan_neighbor_iterator<Ct, DistanceType, Diff> >::type
420  manhattan_neighbor_lower_bound
421  (Ct& container, const Diff& diff,
422  const typename container_traits<Ct>::key_type& target,
423  DistanceType bound)
424  {
425  return neighbor_lower_bound
426  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
427  }
428 
429  template <typename Ct, typename Diff, typename DistanceType>
430  inline typename
431  enable_if<import::is_arithmetic<DistanceType>,
432  manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type
433  manhattan_neighbor_lower_bound
434  (const Ct& container, const Diff& diff,
435  const typename container_traits<Ct>::key_type& target,
436  DistanceType bound)
437  {
438  return neighbor_lower_bound
439  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
440  }
441 
442  template <typename Ct, typename Diff, typename DistanceType>
443  inline typename
444  enable_if<import::is_arithmetic<DistanceType>,
445  manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type
446  manhattan_neighbor_clower_bound
447  (const Ct& container, const Diff& diff,
448  const typename container_traits<Ct>::key_type& target,
449  DistanceType bound)
450  {
451  return neighbor_lower_bound
452  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
453  }
455 
464  template <typename Ct, typename DistanceType>
466  inline typename
467  enable_if_c<details::is_compare_builtin<Ct>::value
468  && import::is_arithmetic<DistanceType>::value,
469  manhattan_neighbor_iterator<Ct, DistanceType> >::type
470  manhattan_neighbor_lower_bound
471  (Ct& container,
472  const typename container_traits<Ct>::key_type& target,
473  DistanceType bound)
474  {
475  return neighbor_lower_bound
476  (container,
477  manhattan<Ct, DistanceType, typename
478  details::with_builtin_difference<Ct>::type>
479  (details::with_builtin_difference<Ct>()(container)),
480  target, bound);
481  }
482 
483  template <typename Ct, typename DistanceType>
484  inline typename
485  enable_if_c<details::is_compare_builtin<Ct>::value
486  && import::is_arithmetic<DistanceType>::value,
487  manhattan_neighbor_iterator<const Ct, DistanceType> >::type
488  manhattan_neighbor_lower_bound
489  (const Ct& container,
490  const typename container_traits<Ct>::key_type& target,
491  DistanceType bound)
492  {
493  return neighbor_lower_bound
494  (container,
495  manhattan<Ct, double,
496  typename details::with_builtin_difference<Ct>::type>
497  (details::with_builtin_difference<Ct>()(container)),
498  target, bound);
499  }
500 
501  template <typename Ct, typename DistanceType>
502  inline typename
503  enable_if_c<details::is_compare_builtin<Ct>::value
504  && import::is_arithmetic<DistanceType>::value,
505  manhattan_neighbor_iterator<const Ct, DistanceType> >::type
506  manhattan_neighbor_clower_bound
507  (const Ct& container,
508  const typename container_traits<Ct>::key_type& target,
509  DistanceType bound)
510  {
511  return neighbor_lower_bound
512  (container,
513  manhattan<Ct, double,
514  typename details::with_builtin_difference<Ct>::type>
515  (details::with_builtin_difference<Ct>()(container)),
516  target, bound);
517  }
519 
529  template <typename Ct, typename Diff, typename DistanceType>
531  inline typename
532  enable_if<import::is_arithmetic<DistanceType>,
533  manhattan_neighbor_iterator<Ct, DistanceType, Diff> >::type
534  manhattan_neighbor_upper_bound
535  (Ct& container, const Diff& diff,
536  const typename container_traits<Ct>::key_type& target,
537  DistanceType bound)
538  {
539  return neighbor_upper_bound
540  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
541  }
542 
543  template <typename Ct, typename Diff, typename DistanceType>
544  inline typename
545  enable_if<import::is_arithmetic<DistanceType>,
546  manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type
547  manhattan_neighbor_upper_bound
548  (const Ct& container, const Diff& diff,
549  const typename container_traits<Ct>::key_type& target,
550  DistanceType bound)
551  {
552  return neighbor_upper_bound
553  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
554  }
555 
556  template <typename Ct, typename Diff, typename DistanceType>
557  inline typename
558  enable_if<import::is_arithmetic<DistanceType>,
559  manhattan_neighbor_iterator<const Ct, DistanceType, Diff> >::type
560  manhattan_neighbor_cupper_bound
561  (const Ct& container, const Diff& diff,
562  const typename container_traits<Ct>::key_type& target,
563  DistanceType bound)
564  {
565  return neighbor_upper_bound
566  (container, manhattan<Ct, DistanceType, Diff>(diff), target, bound);
567  }
569 
578  template <typename Ct, typename DistanceType>
580  inline typename
581  enable_if_c<details::is_compare_builtin<Ct>::value
582  && import::is_arithmetic<DistanceType>::value,
583  manhattan_neighbor_iterator<Ct, DistanceType> >::type
584  manhattan_neighbor_upper_bound
585  (Ct& container,
586  const typename container_traits<Ct>::key_type& target,
587  DistanceType bound)
588  {
589  return neighbor_upper_bound
590  (container,
591  manhattan<Ct, DistanceType, typename
592  details::with_builtin_difference<Ct>::type>
593  (details::with_builtin_difference<Ct>()(container)),
594  target, bound);
595  }
596 
597  template <typename Ct, typename DistanceType>
598  inline typename
599  enable_if_c<details::is_compare_builtin<Ct>::value
600  && import::is_arithmetic<DistanceType>::value,
601  manhattan_neighbor_iterator<const Ct, DistanceType> >::type
602  manhattan_neighbor_upper_bound
603  (const Ct& container,
604  const typename container_traits<Ct>::key_type& target,
605  DistanceType bound)
606  {
607  return neighbor_upper_bound
608  (container,
609  manhattan<Ct, double,
610  typename details::with_builtin_difference<Ct>::type>
611  (details::with_builtin_difference<Ct>()(container)),
612  target, bound);
613  }
614 
615  template <typename Ct, typename DistanceType>
616  inline typename
617  enable_if_c<details::is_compare_builtin<Ct>::value
618  && import::is_arithmetic<DistanceType>::value,
619  manhattan_neighbor_iterator<const Ct, DistanceType> >::type
620  manhattan_neighbor_cupper_bound
621  (const Ct& container,
622  const typename container_traits<Ct>::key_type& target,
623  DistanceType bound)
624  {
625  return neighbor_upper_bound
626  (container,
627  manhattan<Ct, double,
628  typename details::with_builtin_difference<Ct>::type>
629  (details::with_builtin_difference<Ct>()(container)),
630  target, bound);
631  }
633 
652  template <typename Ct, typename Diff>
654  inline manhattan_neighbor_iterator_pair<Ct, double, Diff>
655  manhattan_neighbor_range
656  (Ct& container, const Diff& diff,
657  const typename container_traits<Ct>::key_type& target)
658  {
659  return neighbor_range
660  (container, manhattan<Ct, double, Diff>(diff), target);
661  }
662 
663  template <typename Ct, typename Diff>
664  inline manhattan_neighbor_iterator_pair<const Ct, double, Diff>
665  manhattan_neighbor_range
666  (const Ct& container, const Diff& diff,
667  const typename container_traits<Ct>::key_type& target)
668  {
669  return neighbor_range
670  (container, manhattan<Ct, double, Diff>(diff), target);
671  }
672 
673  template <typename Ct, typename Diff>
674  inline manhattan_neighbor_iterator_pair<const Ct, double, Diff>
675  manhattan_neighbor_crange
676  (const Ct& container, const Diff& diff,
677  const typename container_traits<Ct>::key_type& target)
678  {
679  return neighbor_range
680  (container, manhattan<Ct, double, Diff>(diff), target);
681  }
683 
701  template <typename Ct>
703  inline typename
704  enable_if<details::is_compare_builtin<Ct>,
705  manhattan_neighbor_iterator_pair<Ct, double> >::type
706  manhattan_neighbor_range
707  (Ct& container,
708  const typename container_traits<Ct>::key_type& target)
709  {
710  return neighbor_range
711  (container,
712  manhattan<Ct, double,
713  typename details::with_builtin_difference<Ct>::type>
714  (details::with_builtin_difference<Ct>()(container)),
715  target);
716  }
717 
718  template <typename Ct>
719  inline typename
720  enable_if<details::is_compare_builtin<Ct>,
721  manhattan_neighbor_iterator_pair<const Ct, double> >::type
722  manhattan_neighbor_range
723  (const Ct& container,
724  const typename container_traits<Ct>::key_type& target)
725  {
726  return neighbor_range
727  (container,
728  manhattan<Ct, double,
729  typename details::with_builtin_difference<Ct>::type>
730  (details::with_builtin_difference<Ct>()(container)),
731  target);
732  }
733 
734  template <typename Ct>
735  inline typename
736  enable_if<details::is_compare_builtin<Ct>,
737  manhattan_neighbor_iterator_pair<const Ct, double> >::type
738  manhattan_neighbor_crange
739  (const Ct& container,
740  const typename container_traits<Ct>::key_type& target)
741  {
742  return neighbor_range
743  (container,
744  manhattan<Ct, double,
745  typename details::with_builtin_difference<Ct>::type>
746  (details::with_builtin_difference<Ct>()(container)),
747  target);
748  }
750 
751 } // namespace spatial
752 
753 #endif // SPATIAL_MANHATTAN_NEIGHBOR_HPP
spatial::manhattan_neighbor_cend
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.
Definition: spatial_manhattan_neighbor.hpp:331
spatial::manhattan_neighbor_iterator< const Ct, DistanceType, Diff >
Definition: spatial_manhattan_neighbor.hpp:63
spatial::manhattan_neighbor_iterator_pair< const Ct, DistanceType, Diff >::manhattan_neighbor_iterator_pair
manhattan_neighbor_iterator_pair()
Definition: spatial_manhattan_neighbor.hpp:146
spatial::manhattan_neighbor_lower_bound
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 fa...
Definition: spatial_manhattan_neighbor.hpp:421
spatial::manhattan_neighbor_crange
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 ...
Definition: spatial_manhattan_neighbor.hpp:676
spatial::manhattan_neighbor_iterator::manhattan_neighbor_iterator
manhattan_neighbor_iterator()
Definition: spatial_manhattan_neighbor.hpp:50
spatial::enable_if
Definition: spatial_check_concept.hpp:43
spatial::neighbor_range
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...
Definition: spatial_neighbor.hpp:1046
spatial::manhattan_neighbor_clower_bound
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 fa...
Definition: spatial_manhattan_neighbor.hpp:447
spatial::manhattan_neighbor_iterator< const Ct, DistanceType, Diff >::check_concept_distance_type_is_arithmetic
enable_if< import::is_arithmetic< DistanceType > > check_concept_distance_type_is_arithmetic
Definition: spatial_manhattan_neighbor.hpp:68
spatial::manhattan_neighbor_end
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.
Definition: spatial_manhattan_neighbor.hpp:311
spatial::manhattan_neighbor_cupper_bound
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 bou...
Definition: spatial_manhattan_neighbor.hpp:561
spatial::neighbor_lower_bound
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...
Definition: spatial_neighbor.hpp:825
spatial::neighbor_end
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.
Definition: spatial_neighbor.hpp:634
spatial::neighbor_iterator
A spatial iterator for a container Ct that goes through the nearest to the furthest element from a ta...
Definition: spatial_neighbor.hpp:115
spatial::manhattan_neighbor_begin
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. ...
Definition: spatial_manhattan_neighbor.hpp:194
spatial::manhattan_neighbor_range
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 ...
Definition: spatial_manhattan_neighbor.hpp:656
spatial::container_traits
The traits type for all containers in the spatial namespace.
Definition: traits.hpp:42
spatial::manhattan_neighbor_iterator_pair::manhattan_neighbor_iterator_pair
manhattan_neighbor_iterator_pair()
Definition: spatial_manhattan_neighbor.hpp:119
spatial::manhattan_neighbor_iterator_pair< const Ct, DistanceType, Diff >
Definition: spatial_manhattan_neighbor.hpp:137
spatial::neighbor_iterator_pair
This structure defines a pair of neighbor iterator.
Definition: spatial_neighbor.hpp:569
spatial::manhattan_neighbor_iterator::check_concept_distance_type_is_arithmetic
enable_if< import::is_arithmetic< DistanceType > >::type check_concept_distance_type_is_arithmetic
Definition: spatial_manhattan_neighbor.hpp:47
spatial::neighbor_upper_bound
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...
Definition: spatial_neighbor.hpp:936
spatial::manhattan_neighbor_iterator< const Ct, DistanceType, Diff >::manhattan_neighbor_iterator
manhattan_neighbor_iterator()
Definition: spatial_manhattan_neighbor.hpp:71
spatial
The main namespace used in the library.
Definition: algorithm.hpp:23
spatial::manhattan_neighbor_iterator_pair< const Ct, DistanceType, Diff >::check_concept_distance_type_is_arithmetic
enable_if< import::is_arithmetic< DistanceType > > check_concept_distance_type_is_arithmetic
Definition: spatial_manhattan_neighbor.hpp:143
spatial::manhattan
Defines a metric for the a space where distances are the sum of all the elements of the vector...
Definition: metric.hpp:231
spatial::neighbor_begin
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...
Definition: spatial_neighbor.hpp:723
spatial::manhattan_neighbor_iterator_pair::check_concept_distance_type_is_arithmetic
enable_if< import::is_arithmetic< DistanceType > > check_concept_distance_type_is_arithmetic
Definition: spatial_manhattan_neighbor.hpp:116
spatial::details::with_builtin_difference
The generic helper class to determine if a container uses a built-in compare type.
Definition: spatial_builtin.hpp:70
spatial::manhattan_neighbor_upper_bound
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 bou...
Definition: spatial_manhattan_neighbor.hpp:535
spatial::manhattan_neighbor_iterator_pair
Facilitate the creation of an iterator range representing a sequence from closest to furthest from th...
Definition: spatial_manhattan_neighbor.hpp:111
spatial::manhattan_neighbor_cbegin
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. ...
Definition: spatial_manhattan_neighbor.hpp:214
spatial::manhattan_neighbor_iterator
Facilitate the creation of neighbor iterator that works with a manhattan metric.
Definition: spatial_manhattan_neighbor.hpp:42