binary searching with bench

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;

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));
+}

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))
+}