range_search.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_RANGE_SEARCH_RANGE_SEARCH_HPP
#define MLPACK_METHODS_RANGE_SEARCH_RANGE_SEARCH_HPP
 
#include <mlpack/prereqs.hpp>
#include <mlpack/core/metrics/lmetric.hpp>
#include <mlpack/core/tree/binary_space_tree.hpp>
#include "range_search_stat.hpp"
 
namespace mlpack {
namespace range  {
 
class TrainVisitor;
 
template<typename MetricType = metric::EuclideanDistance,
         typename MatType = arma::mat,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType = tree::KDTree>
class RangeSearch
{
 public:
  typedef TreeType<MetricType, RangeSearchStat, MatType> Tree;
 
  RangeSearch(MatType referenceSet,
              const bool naive = false,
              const bool singleMode = false,
              const MetricType metric = MetricType());
 
  RangeSearch(Tree* referenceTree,
              const bool singleMode = false,
              const MetricType metric = MetricType());
 
  RangeSearch(const bool naive = false,
              const bool singleMode = false,
              const MetricType metric = MetricType());
 
  RangeSearch(const RangeSearch& other);
 
  RangeSearch(RangeSearch&& other);
 
  RangeSearch& operator=(RangeSearch other);
 
  ~RangeSearch();
 
  void Train(MatType referenceSet);
 
  void Train(Tree* referenceTree);
 
  void Search(const MatType& querySet,
              const math::Range& range,
              std::vector<std::vector<size_t>>& neighbors,
              std::vector<std::vector<double>>& distances);
 
  void Search(Tree* queryTree,
              const math::Range& range,
              std::vector<std::vector<size_t>>& neighbors,
              std::vector<std::vector<double>>& distances);
 
  void Search(const math::Range& range,
              std::vector<std::vector<size_t>>& neighbors,
              std::vector<std::vector<double>>& distances);
 
  bool SingleMode() const { return singleMode; }
  bool& SingleMode() { return singleMode; }
 
  bool Naive() const { return naive; }
  bool& Naive() { return naive; }
 
  size_t BaseCases() const { return baseCases; }
  size_t Scores() const { return scores; }
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int version);
 
  const MatType& ReferenceSet() const { return *referenceSet; }
 
  Tree* ReferenceTree() { return referenceTree; }
 
 private:
  std::vector<size_t> oldFromNewReferences;
  Tree* referenceTree;
  const MatType* referenceSet;
 
  bool treeOwner;
 
  bool naive;
  bool singleMode;
 
  MetricType metric;
 
  size_t baseCases;
  size_t scores;
 
  friend class TrainVisitor;
};
 
} // namespace range
} // namespace mlpack
 
// Include implementation.
#include "range_search_impl.hpp"
 
#endif