Add fuzzy test and Readme; solves #18

kd_tree/README.md

@@ -0,0 +1,8 @@
+# KD-Tree implementation
+
+Implements only functions required for searching an already initialized KD-Tree.  
+Because of this, this crate is no_std compatible  
+
+Code for building the KD-Tree can be found in `kd_tree_sort`.  
+`kd_tree_sort` is not no_std compatible which is why these two crates were seperated.  
+A fuzzy tester as well as a benchmark verifying this implementation can be found in `kd_tree_sort`.

kd_tree_sort/Cargo.toml

@@ -15,6 +15,9 @@ rand_pcg = "*"
 itertools = "0.10"
 criterion = "0.3"
 
+[lib]
+bench = false
+
 [[bench]]
 name = "search"
 harness = false

kd_tree_sort/README.md

@@ -0,0 +1,19 @@
+# KD-Tree sort implemention
+
+Implements a non-no_std compatible sort function for usage with the `kd_tree` crate.
+
+## Benchmark
+For benchmarking purposed, criterion.rs was used, comparing our kd-tree against a basic linear_search.
+
+Run: `cargo bench` in this directory.
+
+## Fuzzy Test
+The implemented fuzzy test uses `cargo fuzz`  
+Install it before running the fuzzy test (a nightly toolchain may be required).  
+
+It compares the result of the linear search algorithm against the result of the kd-tree search.  
+The fuzzy test input is filtering out `Inf` and `NaN` values since our kd-tree is 
+supposed to find the nearest-neighbor on valid input data only.
+
+For starting the fuzzy test run: `cargo fuzz run kd_tree_search --sanitizer=leak` in this directory.  
+*Note: the fuzzy test will run until it finds an error*

kd_tree_sort/benches/search.rs

@@ -1,8 +1,8 @@
-use std::time::Duration;
-use criterion::{criterion_group, criterion_main, Criterion, BenchmarkId, BatchSize};
+use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
 use kd_tree::{euclid, Node, Tree};
-use rand::Rng;
 use kd_tree_sort::sort;
+use rand::Rng;
+use std::time::Duration;
 
 type Prng = rand_pcg::Mcg128Xsl64;
 
@@ -15,17 +15,15 @@ fn linear_search(nodes: &[Node<f64, i32, 3>], point: &[f64; 3]) -> f64 {
 }
 
 fn generate_values(len: usize, rng: &mut Prng) -> Vec<([f64; 3], i32)> {
-    (0..len)
-        .map(|_| (generate_point(rng), 0))
-        .collect()
+    (0..len).map(|_| (generate_point(rng), 0)).collect()
 }
 
-fn generate_sorted(len: usize, rng: &mut Prng) -> Vec<Node<f64, i32, 3>>{
+fn generate_sorted(len: usize, rng: &mut Prng) -> Vec<Node<f64, i32, 3>> {
     let sorted = sort(generate_values(len, rng));
     sorted.iter().map(|(p, v)| Node::new(*p, *v)).collect()
 }
 
-fn generate_point(rng: &mut Prng) -> [f64; 3]{
+fn generate_point(rng: &mut Prng) -> [f64; 3] {
     [rng.gen(), rng.gen(), rng.gen()]
 }
 
@@ -41,19 +39,27 @@ pub fn search(c: &mut Criterion) {
     group.warm_up_time(Duration::from_millis(50));
     group.measurement_time(Duration::from_secs(1));
 
-    for len in (START_LEN..END_LEN).step_by(1000){
+    for len in (START_LEN..END_LEN).step_by(1000) {
         let nodes = generate_sorted(len, &mut rng);
         let tree = Tree::<f64, i32, 3, MAX_LEVEL> {
-            nodes: nodes.as_slice()
+            nodes: nodes.as_slice(),
         };
-        group.bench_with_input(BenchmarkId::new("KD Tree", len),
-                               &tree, |b, t|
-                                   b.iter_batched(|| generate_point(&mut rng),|p| t.search(&p), BatchSize::SmallInput));
-        group.bench_with_input(BenchmarkId::new("Linear", len),
-                               &nodes, |b, n|
-                                   b.iter_batched(|| generate_point(&mut rng),|p| linear_search(n, &p), BatchSize::SmallInput));
+        group.bench_with_input(BenchmarkId::new("KD Tree", len), &tree, |b, t| {
+            b.iter_batched(
+                || generate_point(&mut rng),
+                |p| t.search(&p),
+                BatchSize::SmallInput,
+            )
+        });
+        group.bench_with_input(BenchmarkId::new("Linear", len), &nodes, |b, n| {
+            b.iter_batched(
+                || generate_point(&mut rng),
+                |p| linear_search(n, &p),
+                BatchSize::SmallInput,
+            )
+        });
     }
 }
 
 criterion_group!(benches, search);
-criterion_main!(benches);
+criterion_main!(benches);

kd_tree_sort/fuzz/.gitignore

@@ -0,0 +1,3 @@
+target
+corpus
+artifacts