Enum CommonNearestNeighbour

#[non_exhaustive]
pub enum CommonNearestNeighbour {
    LinearSearch,
    KdTree,
    BallTree,
}

Enum that dispatches to one of the crate’s NearestNeighbour implementations based on value. This enum should be used instead of using types like LinearSearch and KdTree directly.

Example

use rand_xoshiro::Xoshiro256Plus;
use ndarray_rand::{rand::SeedableRng, rand_distr::Uniform, RandomExt};
use ndarray::{Array1, Array2};
use linfa_nn::{distance::*, CommonNearestNeighbour, NearestNeighbour};

// Use seedable RNG for generating points
let mut rng = Xoshiro256Plus::seed_from_u64(40);
let n_features = 3;
let distr = Uniform::new(-500., 500.);
// Randomly generate points for building the index
let points = Array2::random_using((5000, n_features), distr, &mut rng);

// Build a K-D tree with Euclidean distance as the distance function
let nn = CommonNearestNeighbour::KdTree.from_batch(&points, L2Dist).unwrap();

let pt = Array1::random_using(n_features, distr, &mut rng);
// Compute the 10 nearest points to `pt` in the index
let nearest = nn.k_nearest(pt.view(), 10).unwrap();
// Compute all points within 100 units of `pt`
let range = nn.within_range(pt.view(), 100.0).unwrap();

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

LinearSearch

Linear search

KdTree

KD Tree

BallTree

Ball Tree

Trait Implementations

impl Clone for CommonNearestNeighbour

fn clone(&self) -> CommonNearestNeighbour

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommonNearestNeighbour

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl NearestNeighbour for CommonNearestNeighbour

fn from_batch_with_leaf_size<'a, F: Float, DT: Data<Elem = F>, D: 'a + Distance<F>>( &self, batch: &'a ArrayBase<DT, Ix2>, leaf_size: usize, dist_fn: D, ) -> Result<Box<dyn Send + Sync + NearestNeighbourIndex<F> + 'a>, BuildError>

Builds a spatial index using a MxN two-dimensional array representing M points with N dimensions. Also takes leaf_size, which specifies the number of elements in the leaf nodes of tree-like index structures.

fn from_batch<'a, F: Float, DT: Data<Elem = F>, D: 'a + Distance<F>>( &self, batch: &'a ArrayBase<DT, Ix2>, dist_fn: D, ) -> Result<Box<dyn Send + Sync + NearestNeighbourIndex<F> + 'a>, BuildError>

Builds a spatial index using a default leaf size. See from_batch_with_leaf_size for more information.

impl PartialEq for CommonNearestNeighbour

fn eq(&self, other: &CommonNearestNeighbour) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CommonNearestNeighbour

impl StructuralPartialEq for CommonNearestNeighbour