hgg 0.4.1

Approximate nearest neighbor search collection
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#![cfg(feature = "serde")]

#[macro_use]
extern crate std;

use bitarray::{BitArray, Hamming};
use hgg::{Hgg, HggLite};
use rand::{Rng, SeedableRng};
use space::{Knn, KnnInsert};

#[test]
fn serde_json_bincode_round_trip_lite() {
    let mut hgg: HggLite<Hamming, BitArray<32>, ()> = HggLite::default().insert_knn(100);

    // Use a PRNG with good statistical properties for generating 64-bit numbers.
    let mut rng = rand_xoshiro::Xoshiro256PlusPlus::seed_from_u64(0);

    // Generate random keys.
    let keys: Vec<BitArray<32>> = (&mut rng)
        .sample_iter::<[u8; 32], _>(rand::distributions::Standard)
        .map(BitArray::new)
        .take(1 << 8)
        .collect();

    // Insert keys into HGG.
    for &key in &keys {
        hgg.insert(key, ());
    }

    // Find the 10 nearest neighbors to every node.
    let old_knns: Vec<Vec<_>> = keys.iter().map(|k| hgg.knn(k, 10)).collect();

    // Serialize and deserialize with both serde_json and bincode back-to-back.
    let hgg: HggLite<Hamming, BitArray<32>, ()> = serde_json::from_str(
        &serde_json::to_string(&hgg).expect("failed to serialize with serde_json"),
    )
    .expect("failed to deserialize with serde_json");
    let mut bdata = vec![];
    bincode::serialize_into(&mut bdata, &hgg).expect("failed to serialize with bincode");
    let hgg: HggLite<Hamming, BitArray<32>, ()> =
        bincode::deserialize_from(bdata.as_slice()).expect("failed to deserialize with bincode");

    // Find the 10 nearest neighbors to every node again.
    let new_knns: Vec<Vec<_>> = keys.iter().map(|k| hgg.knn(k, 10)).collect();

    // If they are exactly equal, everything worked as expected.
    assert_eq!(old_knns, new_knns);
}

#[test]
fn serde_json_bincode_round_trip_hgg() {
    let mut hgg: Hgg<Hamming, BitArray<32>, ()> = Hgg::default().insert_knn(100);

    // Use a PRNG with good statistical properties for generating 64-bit numbers.
    let mut rng = rand_xoshiro::Xoshiro256PlusPlus::seed_from_u64(0);

    // Generate random keys.
    let keys: Vec<BitArray<32>> = (&mut rng)
        .sample_iter::<[u8; 32], _>(rand::distributions::Standard)
        .map(BitArray::new)
        .take(1 << 8)
        .collect();

    // Insert keys into HGG.
    for &key in &keys {
        hgg.insert(key, ());
    }

    // Find the 10 nearest neighbors to every node.
    let old_knns: Vec<Vec<_>> = keys.iter().map(|k| hgg.knn(k, 10)).collect();

    // Serialize and deserialize with both serde_json and bincode back-to-back.
    let hgg: Hgg<Hamming, BitArray<32>, ()> = serde_json::from_str(
        &serde_json::to_string(&hgg).expect("failed to serialize with serde_json"),
    )
    .expect("failed to deserialize with serde_json");
    let mut bdata = vec![];
    bincode::serialize_into(&mut bdata, &hgg).expect("failed to serialize with bincode");
    let hgg: Hgg<Hamming, BitArray<32>, ()> =
        bincode::deserialize_from(bdata.as_slice()).expect("failed to deserialize with bincode");

    // Find the 10 nearest neighbors to every node again.
    let new_knns: Vec<Vec<_>> = keys.iter().map(|k| hgg.knn(k, 10)).collect();

    // If they are exactly equal, everything worked as expected.
    assert_eq!(old_knns, new_knns);
}