According to the API doc, there is a find_nearest function. However, by default, it can only return the nearest neighbor node. How can I find out at most N nearest neighbors? This is import for interpolation.

Thanks for the library! I found it really useful but thought it would be really nice to include some examples of the uses of find_nearest_custom, this pull request adds two new examples that can be used to find all the neighbours in a radius or the N nearest neighbours.

This also adds the Default and Debug traits to the Distance item, this makes it easier to build / debug these BestCandidate implementations.

This fixes: https://github.com/kornelski/vpsearch/issues/1

Hi,

I'm a newbie to Rust, I want use this library to write an application for sequence processing. But there are somethig confusing me. Here is my simplified code:

use strsim::{hamming};
extern crate vpsearch;

#[derive(Copy, Clone)]
struct Barcode<'a> {
    code: &'a String
}

impl<'a> Barcode<'a> {
    fn new(code: &'a String) -> Self {
        Barcode {
            code: code
        }
    }
}

impl<'a> vpsearch::MetricSpace for Barcode<'a> {
    type UserData = ();
    type Distance = f32;

    fn distance<'b>(&self, other: &'b Self, _: &Self::UserData) -> Self::Distance {
        let d = hamming(self.code, other.code).unwrap();
        d as f32
    }
}


fn main() {
    let seqs: Vec<String> = vec!["AATT", "TTCC"].iter().map(|s| s.to_string()).collect();
    let mut items = vec![];
    for i in 0..seqs.len() {
        items.push(Barcode::new(&seqs[i]));
    }
    let tree = vpsearch::Tree::new(&items);

    {
        let q = "TATT".to_string();
        let q = Barcode::new(&q);
        let (index, dist) = tree.find_nearest(&q);
        println!("{} {}", index, dist);
    }
    {
        let q = "TTCA".to_string();
        let q = Barcode::new(&q);
        let (index, dist) = tree.find_nearest(&q);
        println!("{} {}", index, dist);
    }
}

Compile it, got:

error[E0597]: `q` does not live long enough
  --> src/main.rs:38:30
   |
38 |         let q = Barcode::new(&q);
   |                              ^^ borrowed value does not live long enough
...
41 |     }
   |     - `q` dropped here while still borrowed
...
45 |         let (index, dist) = tree.find_nearest(&q);
   |                             ---- borrow later used here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0597`.
error: could not compile `vptest`.

In the real application, for saving the memory the query should be droped when it has been processed. Is there are any solution to make the query item and tree have independent lifetimes?

Would it be possible to implement serde's Serialize and Deserialize for the Tree struct? This would allow me to generate the tree, save it to a file and load it when I need it to speed up things.

First of all, I have to say thank you for this library; I have found it extremely useful, ergonomic and it is an essential part of the project I am using it in.

As the size of the input data I am processing increases I have found the creation of the tree becomes a bottleneck as it is CPU bound and limited to only 1 core with the current implementation.

I have only skimmed the codebase and am generally unfamiliar with the creation of VP trees, but it appears a few choice applications of Rayon's parallel iterators (in the index sorting for example) would greatly reduce the creation time of the tree structure.

I'll be experimenting with it over the coming days but wanted to raise this issue to get your thoughts on this approach.

Thank you again.