ra_search.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_RANN_RA_SEARCH_HPP
#define MLPACK_METHODS_RANN_RA_SEARCH_HPP

#include <mlpack/prereqs.hpp>

#include <mlpack/core/tree/binary_space_tree.hpp>

#include <mlpack/core/metrics/lmetric.hpp>
#include <mlpack/methods/neighbor_search/sort_policies/nearest_neighbor_sort.hpp>

#include "ra_query_stat.hpp"
#include "ra_util.hpp"

namespace mlpack {
namespace neighbor {

// Forward declaration.
template<typename SortPolicy>
class TrainVisitor;

template<typename SortPolicy = NearestNeighborSort,
         typename MetricType = metric::EuclideanDistance,
         typename MatType = arma::mat,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType = tree::KDTree>
class RASearch
{
 public:
  typedef TreeType<MetricType, RAQueryStat<SortPolicy>, MatType> Tree;

  RASearch(MatType referenceSet,
           const bool naive = false,
           const bool singleMode = false,
           const double tau = 5,
           const double alpha = 0.95,
           const bool sampleAtLeaves = false,
           const bool firstLeafExact = false,
           const size_t singleSampleLimit = 20,
           const MetricType metric = MetricType());

  RASearch(Tree* referenceTree,
           const bool singleMode = false,
           const double tau = 5,
           const double alpha = 0.95,
           const bool sampleAtLeaves = false,
           const bool firstLeafExact = false,
           const size_t singleSampleLimit = 20,
           const MetricType metric = MetricType());

  RASearch(const bool naive = false,
           const bool singleMode = false,
           const double tau = 5,
           const double alpha = 0.95,
           const bool sampleAtLeaves = false,
           const bool firstLeafExact = false,
           const size_t singleSampleLimit = 20,
           const MetricType metric = MetricType());

  ~RASearch();

  void Train(MatType referenceSet);

  void Train(Tree* referenceTree);

  void Search(const MatType& querySet,
              const size_t k,
              arma::Mat<size_t>& neighbors,
              arma::mat& distances);

  void Search(Tree* queryTree,
              const size_t k,
              arma::Mat<size_t>& neighbors,
              arma::mat& distances);

  void Search(const size_t k,
              arma::Mat<size_t>& neighbors,
              arma::mat& distances);

  void ResetQueryTree(Tree* queryTree) const;

  const MatType& ReferenceSet() const { return *referenceSet; }

  bool Naive() const { return naive; }
  bool& Naive() { return naive; }

  bool SingleMode() const { return singleMode; }
  bool& SingleMode() { return singleMode; }

  double Tau() const { return tau; }
  double& Tau() { return tau; }

  double Alpha() const { return alpha; }
  double& Alpha() { return alpha; }

  bool SampleAtLeaves() const { return sampleAtLeaves; }
  bool& SampleAtLeaves() { return sampleAtLeaves; }

  bool FirstLeafExact() const { return firstLeafExact; }
  bool& FirstLeafExact() { return firstLeafExact; }

  size_t SingleSampleLimit() const { return singleSampleLimit; }
  size_t& SingleSampleLimit() { return singleSampleLimit; }

  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */);

 private:
  std::vector<size_t> oldFromNewReferences;
  Tree* referenceTree;
  const MatType* referenceSet;

  bool treeOwner;
  bool setOwner;

  bool naive;
  bool singleMode;

  double tau;
  double alpha;
  bool sampleAtLeaves;
  bool firstLeafExact;
  size_t singleSampleLimit;

  MetricType metric;

  template<typename SortPol>
  friend class TrainVisitor;
}; // class RASearch

} // namespace neighbor
} // namespace mlpack

// Include implementation.
#include "ra_search_impl.hpp"

// Include convenient typedefs.
#include "ra_typedef.hpp"

#endif