From b43510b33e49be1066613009f07f08e52ca14ce1 Mon Sep 17 00:00:00 2001
From: Anson Biggs <anson@ansonbiggs.com>
Date: Mon, 25 Apr 2022 21:02:23 -0700
Subject: [PATCH] final code

---
 golang/main.go     | 11 ++++-------
 rust/.rustfmt.toml |  1 +
 rust/src/main.rs   | 37 ++++++++++++++++++++++---------------
 3 files changed, 27 insertions(+), 22 deletions(-)
 create mode 100644 rust/.rustfmt.toml

diff --git a/golang/main.go b/golang/main.go
index 32c468c..e905223 100644
--- a/golang/main.go
+++ b/golang/main.go
@@ -21,7 +21,6 @@ func quicksort(slice []int) {
 }
 
 func par_quicksort(slice []int) {
-
 	if len(slice) <= 1 {
 		return
 	}
@@ -89,7 +88,6 @@ func choose_pivot(slice []int) int {
 	} else {
 		return mid
 	}
-
 }
 
 func swap(slice []int, a int, b int) {
@@ -103,18 +101,17 @@ func main() {
 	sortSize := 20000000
 	// MAXGOROUTINES := 1
 	unsorted := make([]int, 0, sortSize)
-	unsorted = rand.Perm(sortSize)
 
 	start := time.Now()
+	unsorted = rand.Perm(sortSize)
 	quicksort(unsorted)
 	duration := time.Since(start)
-	fmt.Println("single ", duration)
+	fmt.Println("Single Threaded: ", duration)
 
-	unsorted = rand.Perm(sortSize)
 	start = time.Now()
+	unsorted = rand.Perm(sortSize)
 	par_quicksort(unsorted)
 	duration = time.Since(start)
-
-	fmt.Println(duration)
+	fmt.Println("Concurrent: ", duration)
 
 }
diff --git a/rust/.rustfmt.toml b/rust/.rustfmt.toml
new file mode 100644
index 0000000..9afaf50
--- /dev/null
+++ b/rust/.rustfmt.toml
@@ -0,0 +1 @@
+max_width = 60
\ No newline at end of file
diff --git a/rust/src/main.rs b/rust/src/main.rs
index 0cc394e..34990b1 100644
--- a/rust/src/main.rs
+++ b/rust/src/main.rs
@@ -3,7 +3,8 @@
 use rayon::join;
 
 fn choose_pivot<T: Ord>(slice: &[T]) -> usize {
-    let (mut left, mid, mut right) = (0, slice.len() / 2, slice.len() - 1);
+    let (mut left, mid, mut right) =
+        (0, slice.len() / 2, slice.len() - 1);
     if slice[right] < slice[left] {
         std::mem::swap(&mut right, &mut left);
     }
@@ -16,7 +17,10 @@ fn choose_pivot<T: Ord>(slice: &[T]) -> usize {
     }
 }
 
-fn partition<T: Ord>(slice: &mut [T], pivot: usize) -> usize {
+fn partition<T: Ord>(
+    slice: &mut [T],
+    pivot: usize,
+) -> usize {
     let mid = slice.len() - 1;
     slice.swap(pivot, mid);
     let (mut left, mut right) = (0, mid - 1);
@@ -62,7 +66,8 @@ fn quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
     }
 
     let pivot = partition(slice, choose_pivot(slice));
-    let (left_slice, right_slice) = slice.split_at_mut(pivot);
+    let (left_slice, right_slice) =
+        slice.split_at_mut(pivot);
 
     let right_slice = &mut right_slice[1..]; // want to exclude pivot
 
@@ -70,7 +75,9 @@ fn quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
     quicksort(right_slice);
 }
 
-fn par_quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
+fn par_quicksort<T: Ord + std::marker::Send>(
+    slice: &mut [T],
+) {
     if slice.len() <= 1 {
         return;
     } else if slice.len() == 2 {
@@ -81,30 +88,30 @@ fn par_quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
     }
 
     let pivot = partition(slice, choose_pivot(slice));
-    let (left_slice, right_slice) = slice.split_at_mut(pivot);
+    let (left_slice, right_slice) =
+        slice.split_at_mut(pivot);
     let right_slice = &mut right_slice[1..]; // want to exclude pivot
 
-    join(|| quicksort(left_slice), || quicksort(right_slice));
+    join(
+        || quicksort(left_slice),
+        || quicksort(right_slice),
+    );
 }
 
-use rand::distributions::{Distribution, Uniform};
+use rand::prelude::SliceRandom;
 use rand::thread_rng;
 fn main() {
-    let mut s: Vec<i32> = Uniform::from(0..1_000_000_000)
-        .sample_iter(&mut thread_rng())
-        .take(100_000)
-        .collect();
+    let mut s = get_bench_vec();
 
     quicksort(&mut s);
+    par_quicksort(&mut s);
 }
 
 extern crate test;
 use test::Bencher;
 fn get_bench_vec() -> Vec<i32> {
-    let s = Uniform::from(0..1_000_000_000)
-        .sample_iter(&mut thread_rng())
-        .take(500_000)
-        .collect();
+    let mut s = (0..20000000).collect::<Vec<i32>>();
+    s.shuffle(&mut thread_rng());
     return s;
 }