Enum linfa_nn::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_isaac::Isaac64Rng;
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 = Isaac64Rng::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 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 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 NearestNeighbourIndex<F> + 'a>, BuildError>

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