From c17a7559d4fec9ca02a499f7daf7d4a6f192fd0a Mon Sep 17 00:00:00 2001
From: Jason Staten <jason.staten@domo.com>
Date: Fri, 8 Jun 2018 22:37:01 -0600
Subject: [PATCH] binary searching with bench

---
 src/lib.rs       | 36 ++--------------------------
 src/search.rs    | 61 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/vec_basic.rs | 32 +++++++++++++++++++++++++
 3 files changed, 95 insertions(+), 34 deletions(-)
 create mode 100644 src/search.rs
 create mode 100644 src/vec_basic.rs

diff --git a/src/lib.rs b/src/lib.rs
index 410bad6..11394fa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,37 +1,5 @@
 #![feature(test)]
 extern crate test;
 
-fn vec_access<T: Copy>(a: &[T]) -> T {
-    a[10000]
-}
-
-use test::Bencher;
-
-#[bench]
-fn bench_vec_access(b: &mut test::Bencher) {
-    let mut a: Vec<usize> = Vec::with_capacity(100000);
-    let len = a.capacity();
-    a.resize(len, 0);
-    println!("{}", a.len());
-    b.iter(|| vec_access(&a))
-}
-
-#[bench]
-fn bench_vec_insert(b: &mut test::Bencher) {
-    // O(n)
-    let mut a: Vec<usize> = Vec::with_capacity(100000);
-    let len = a.capacity();
-    a.resize(len, 0);
-    println!("{}", a.len());
-    b.iter(|| a.insert(0, 1))
-}
-
-#[bench]
-fn bench_vec_push(b: &mut test::Bencher) {
-    // O(1)
-    let mut a: Vec<usize> = Vec::with_capacity(100000);
-    let len = a.capacity();
-    a.resize(len, 0);
-    println!("{}", a.len());
-    b.iter(|| a.push(1))
-}
+pub mod search;
+pub mod vec_basic;
diff --git a/src/search.rs b/src/search.rs
new file mode 100644
index 0000000..7261ce0
--- /dev/null
+++ b/src/search.rs
@@ -0,0 +1,61 @@
+#[allow(unused_imports)]
+extern crate test;
+use test::Bencher;
+
+pub fn brute_force_search<T: PartialEq>(arr: &[T], el: T) -> bool {
+    for i in 0..arr.len() {
+        if arr[i] == el {
+            return true;
+        }
+    }
+    return false;
+}
+
+pub fn binary_search<T: Ord>(arr: &[T], el: T) -> bool {
+    use std::cmp::Ordering;
+    let mut remaining = arr;
+    loop {
+        let middle = remaining.len() / 2;
+        match (remaining, el.cmp(&remaining[middle])) {
+            (_, Ordering::Equal) => return true,
+            ([_], _) => return false,
+            (_, Ordering::Less) => remaining = &remaining[..middle],
+            (_, Ordering::Greater) => remaining = &remaining[middle..],
+        };
+    }
+}
+#[test]
+fn test_brute_force_miss() {
+    let vec: Vec<usize> = (0..100).collect();
+    assert_eq!(brute_force_search(&vec, 101), false)
+}
+
+#[test]
+fn test_brute_force_hit() {
+    let vec: Vec<usize> = (0..100).collect();
+    assert_eq!(brute_force_search(&vec, 42), true)
+}
+
+#[test]
+fn test_binary_miss() {
+    let vec: Vec<usize> = (0..100).collect();
+    assert_eq!(binary_search(&vec, 101), false)
+}
+
+#[test]
+fn test_binary_hit() {
+    let vec: Vec<usize> = (0..100).collect();
+    assert_eq!(binary_search(&vec, 42), true)
+}
+
+#[bench]
+fn bench_brute_force(b: &mut test::Bencher) {
+    let vec: Vec<usize> = (0..1000000).collect();
+    b.iter(|| brute_force_search(&vec, 900000));
+}
+
+#[bench]
+fn bench_binary_search(b: &mut test::Bencher) {
+    let vec: Vec<usize> = (0..1000000).collect();
+    b.iter(|| binary_search(&vec, 900000));
+}
diff --git a/src/vec_basic.rs b/src/vec_basic.rs
new file mode 100644
index 0000000..d383627
--- /dev/null
+++ b/src/vec_basic.rs
@@ -0,0 +1,32 @@
+#[allow(unused_imports)]
+extern crate test;
+use test::Bencher;
+
+#[bench]
+fn bench_vec_access(b: &mut Bencher) {
+    let mut a: Vec<usize> = Vec::with_capacity(100000);
+    let len = a.capacity();
+    a.resize(len, 0);
+    println!("{}", a.len());
+    b.iter(|| a[99999])
+}
+
+#[bench]
+fn bench_vec_insert(b: &mut Bencher) {
+    // O(n)
+    let mut a: Vec<usize> = Vec::with_capacity(100000);
+    let len = a.capacity();
+    a.resize(len, 0);
+    println!("{}", a.len());
+    b.iter(|| a.insert(0, 1))
+}
+
+#[bench]
+fn bench_vec_push(b: &mut Bencher) {
+    // O(1)
+    let mut a: Vec<usize> = Vec::with_capacity(100000);
+    let len = a.capacity();
+    a.resize(len, 0);
+    println!("{}", a.len());
+    b.iter(|| a.push(1))
+}