├── .gitignore
├── depth-first-search
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
├── divide-and-conquer
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
├── division
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
├── fibonacci
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
├── merge-sort
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
├── power-mod
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
    │   └── main.rs
└── prime-check
    ├── Cargo.lock
    ├── Cargo.toml
    └── src
        └── main.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | Algorithms.pdf
2 | .idea
3 | **/*/target/
4 | 


--------------------------------------------------------------------------------
/depth-first-search/Cargo.lock:
--------------------------------------------------------------------------------
1 | # This file is automatically @generated by Cargo.
2 | # It is not intended for manual editing.
3 | version = 3
4 | 
5 | [[package]]
6 | name = "depth-first-search"
7 | version = "0.1.0"
8 | 


--------------------------------------------------------------------------------
/depth-first-search/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "depth-first-search"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/depth-first-search/src/main.rs:
--------------------------------------------------------------------------------
 1 | use std::collections::{HashSet, VecDeque};
 2 | 
 3 | #[derive(Clone, PartialEq, Eq, Hash, Debug, Copy)]
 4 | struct Vertex(u32);
 5 | 
 6 | impl Vertex {
 7 |     pub fn neighbors(&self, graph: &Graph) -> VecDeque<Vertex> {
 8 |         graph
 9 |             .edges
10 |             .iter()
11 |             .filter(|e| e.0 == self.0)
12 |             .map(|e| Vertex::from(e.1.clone()))
13 |             .collect()
14 |     }
15 | }
16 | 
17 | impl From<u32> for Vertex {
18 |     fn from(item: u32) -> Self {
19 |         Vertex(item)
20 |     }
21 | }
22 | 
23 | #[derive(Clone, PartialEq, Eq, Hash, Debug, Copy)]
24 | struct Edge(u32, u32);
25 | 
26 | impl From<(u32, u32)> for Edge {
27 |     fn from(item: (u32, u32)) -> Self {
28 |         Edge(item.0, item.1)
29 |     }
30 | }
31 | 
32 | #[derive(Clone, PartialEq, Eq, Hash, Debug)]
33 | struct Graph {
34 |     vertices: Vec<Vertex>,
35 |     edges: Vec<Edge>,
36 | }
37 | 
38 | impl Graph {
39 |     fn new(vertices: Vec<u32>, edges: Vec<(u32, u32)>) -> Graph {
40 |         Graph {
41 |             vertices: vertices.into_iter().map(|v| Vertex::from(v)).collect(),
42 |             edges: edges.into_iter().map(|e| Edge::from((e.0, e.1))).collect(),
43 |         }
44 |     }
45 | 
46 |     fn traverse(&self) {
47 |         let mut visited: HashSet<Vertex> = HashSet::new();
48 | 
49 |         for vertex in &self.vertices {
50 |             visited.insert(*vertex);
51 | 
52 |             for neighbor in vertex.neighbors(self).into_iter() {
53 |                 if visited.insert(neighbor) {
54 |                     println!(
55 |                         "Tree edge current vertex {:?} to neighbor {:?}",
56 |                         vertex, neighbor
57 |                     );
58 |                 } else {
59 |                     println!(
60 |                         "-- Back edge current vertex {:?} to neighbor {:?}",
61 |                         vertex, neighbor
62 |                     );
63 |                 }
64 |             }
65 |         }
66 |     }
67 | }
68 | 
69 | fn main() {
70 |     let vertices: Vec<u32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
71 |     let edges: Vec<(u32, u32)> = vec![
72 |         (1, 2),
73 |         (2, 3),
74 |         (1, 5),
75 |         (2, 5),
76 |         (3, 6),
77 |         (5, 6),
78 |         (6, 9),
79 |         (4, 7),
80 |         (4, 8),
81 |         (7, 8),
82 |     ];
83 | 
84 |     let graph = Graph::new(vertices, edges);
85 |     graph.traverse();
86 | }
87 | 


--------------------------------------------------------------------------------
/divide-and-conquer/Cargo.lock:
--------------------------------------------------------------------------------
 1 | # This file is automatically @generated by Cargo.
 2 | # It is not intended for manual editing.
 3 | version = 3
 4 | 
 5 | [[package]]
 6 | name = "cfg-if"
 7 | version = "1.0.0"
 8 | source = "registry+https://github.com/rust-lang/crates.io-index"
 9 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
10 | 
11 | [[package]]
12 | name = "divide-and-conquer"
13 | version = "0.1.0"
14 | dependencies = [
15 |  "rand",
16 | ]
17 | 
18 | [[package]]
19 | name = "getrandom"
20 | version = "0.2.4"
21 | source = "registry+https://github.com/rust-lang/crates.io-index"
22 | checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c"
23 | dependencies = [
24 |  "cfg-if",
25 |  "libc",
26 |  "wasi",
27 | ]
28 | 
29 | [[package]]
30 | name = "libc"
31 | version = "0.2.117"
32 | source = "registry+https://github.com/rust-lang/crates.io-index"
33 | checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"
34 | 
35 | [[package]]
36 | name = "ppv-lite86"
37 | version = "0.2.16"
38 | source = "registry+https://github.com/rust-lang/crates.io-index"
39 | checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
40 | 
41 | [[package]]
42 | name = "rand"
43 | version = "0.8.4"
44 | source = "registry+https://github.com/rust-lang/crates.io-index"
45 | checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
46 | dependencies = [
47 |  "libc",
48 |  "rand_chacha",
49 |  "rand_core",
50 |  "rand_hc",
51 | ]
52 | 
53 | [[package]]
54 | name = "rand_chacha"
55 | version = "0.3.1"
56 | source = "registry+https://github.com/rust-lang/crates.io-index"
57 | checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
58 | dependencies = [
59 |  "ppv-lite86",
60 |  "rand_core",
61 | ]
62 | 
63 | [[package]]
64 | name = "rand_core"
65 | version = "0.6.3"
66 | source = "registry+https://github.com/rust-lang/crates.io-index"
67 | checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
68 | dependencies = [
69 |  "getrandom",
70 | ]
71 | 
72 | [[package]]
73 | name = "rand_hc"
74 | version = "0.3.1"
75 | source = "registry+https://github.com/rust-lang/crates.io-index"
76 | checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
77 | dependencies = [
78 |  "rand_core",
79 | ]
80 | 
81 | [[package]]
82 | name = "wasi"
83 | version = "0.10.2+wasi-snapshot-preview1"
84 | source = "registry+https://github.com/rust-lang/crates.io-index"
85 | checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
86 | 


--------------------------------------------------------------------------------
/divide-and-conquer/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "divide-and-conquer"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | rand = "0.8.4"


--------------------------------------------------------------------------------
/divide-and-conquer/src/main.rs:
--------------------------------------------------------------------------------
 1 | use rand::Rng;
 2 | 
 3 | fn create_random_list() -> Vec<i32> {
 4 |     let mut rng = rand::thread_rng();
 5 |     let mut list: Vec<i32> = Vec::new();
 6 | 
 7 |     for _i in 1..2048 {
 8 |         list.push(rng.gen_range(0..5000));
 9 |     }
10 | 
11 |     list.sort();
12 | 
13 |     list
14 | }
15 | 
16 | fn iterative_binary_search(list: &Vec<i32>, element: i32) -> Option<i32> {
17 |     let mut low: usize = 0;
18 |     let mut high: usize = list.len() - 1;
19 |     let mut iteration: i32 = 0;
20 | 
21 |     while low <= high {
22 |         iteration += 1;
23 |         let middle = (high + low) / 2;
24 |         println!("{:?}. Iterating with middle value {:?}", iteration, middle);
25 | 
26 |         if let Some(current) = list.get(middle) {
27 |             if current == &element {
28 |                 return Some(*current);
29 |             }
30 | 
31 |             if current > &element {
32 |                 high = middle - 1
33 |             }
34 | 
35 |             if current < &element {
36 |                 low = middle + 1
37 |             }
38 |         }
39 |     }
40 | 
41 |     None
42 | }
43 | 
44 | fn main() {
45 |     let mut rng = rand::thread_rng();
46 |     let list = create_random_list();
47 | 
48 |     println!(
49 |         "{:?} element",
50 |         iterative_binary_search(&list, rng.gen_range(1..1000))
51 |     )
52 | }
53 | 


--------------------------------------------------------------------------------
/division/Cargo.lock:
--------------------------------------------------------------------------------
1 | # This file is automatically @generated by Cargo.
2 | # It is not intended for manual editing.
3 | version = 3
4 | 
5 | [[package]]
6 | name = "division"
7 | version = "0.1.0"
8 | 


--------------------------------------------------------------------------------
/division/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "division"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/division/src/main.rs:
--------------------------------------------------------------------------------
 1 | fn division(x: u32, y: u32) -> (u32, u32) {
 2 |   if x == 0 {
 3 |     return (0, 0);
 4 |   }
 5 | 
 6 |   let (mut q, mut r) = division(x >> 1, y);
 7 | 
 8 |   q *= 2;
 9 |   r *= 2;
10 | 
11 |   if x % 2 == 1 {
12 |     r += 1;
13 |   }
14 | 
15 |   if r >= y {
16 |     r -= y;
17 |     q += 1;
18 |   }
19 | 
20 |   return (q, r);
21 | }
22 | 
23 | fn main() {
24 |   println!("Answer for 1/1 {:?}", division(1, 1));
25 |   println!("Answer for 2/1 {:?}", division(2, 1));
26 |   println!("Answer for 3/2 {:?}", division(3, 2));
27 | }
28 | 


--------------------------------------------------------------------------------
/fibonacci/Cargo.lock:
--------------------------------------------------------------------------------
1 | # This file is automatically @generated by Cargo.
2 | # It is not intended for manual editing.
3 | version = 3
4 | 
5 | [[package]]
6 | name = "fibonacci"
7 | version = "0.1.0"
8 | 


--------------------------------------------------------------------------------
/fibonacci/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "fibonacci"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/fibonacci/src/main.rs:
--------------------------------------------------------------------------------
 1 | fn recursive_fibonacci(n: u32) -> u32 {
 2 |   return match n {
 3 |     0 => 0,
 4 |     1 => 1,
 5 |     _ => recursive_fibonacci(n-1) + recursive_fibonacci(n-2)
 6 |   };
 7 | }
 8 | 
 9 | fn iterative_fibonacci(n: u32) -> u32 {
10 |   return match n {
11 |     0 => 0,
12 |     1 => 1,
13 |     _ => {
14 |       let mut lhs: u32 = 0;
15 |       let mut rhs: u32 = 1;
16 |       let mut sum: u32 = 1;
17 | 
18 |       for _i in 1..n {
19 |         sum = lhs + rhs;
20 |         lhs = rhs;
21 |         rhs = sum;
22 |       }
23 | 
24 |       return sum;
25 |     }
26 |   }
27 | }
28 | 
29 | fn closed_form_fibonacci(n: f64) -> i32 {
30 |   let lhs = ((1.0 + (5 as f64).sqrt()) / 2.0).powf(n);
31 |   let rhs = ((1.0 - (5 as f64).sqrt()) / 2.0).powf(n);
32 | 
33 |   return ((1.0 / (5 as f64).sqrt()) * (lhs - rhs)) as i32;
34 | }
35 | 
36 | fn main() {
37 |   println!("Recursive fibonacci result {}", recursive_fibonacci(20));
38 |   println!("Iterative fibonacci result {}", iterative_fibonacci(20));
39 |   println!("Closed form fibonacci result {}", closed_form_fibonacci(20.0));
40 | }
41 | 


--------------------------------------------------------------------------------
/merge-sort/Cargo.lock:
--------------------------------------------------------------------------------
1 | # This file is automatically @generated by Cargo.
2 | # It is not intended for manual editing.
3 | version = 3
4 | 
5 | [[package]]
6 | name = "merge-sort"
7 | version = "0.1.0"
8 | 


--------------------------------------------------------------------------------
/merge-sort/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "merge-sort"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/merge-sort/src/main.rs:
--------------------------------------------------------------------------------
 1 | fn merge(left: &Vec<u32>, right: &Vec<u32>) -> Vec<u32> {
 2 |     let mut merged: Vec<u32> = Vec::new();
 3 | 
 4 |     let mut i = 0;
 5 |     let mut j = 0;
 6 | 
 7 |     while i < left.len() && j < right.len() {
 8 |         if left[i] <= right[j] {
 9 |             merged.push(left[i]);
10 |             i += 1;
11 |         } else {
12 |             merged.push(right[j]);
13 |             j += 1;
14 |         }
15 |     }
16 | 
17 |     while i < left.len() {
18 |         merged.push(left[i]);
19 |         i += 1;
20 |     }
21 | 
22 |     while j < right.len() {
23 |         merged.push(right[j]);
24 |         j += 1;
25 |     }
26 | 
27 |     merged
28 | }
29 | 
30 | fn merge_sort(v: Vec<u32>) -> Vec<u32> {
31 |     return if v.len() < 2 {
32 |         v.to_vec()
33 |     } else {
34 |         let size = v.len() / 2;
35 |         let left = merge_sort(v[0..size].to_vec());
36 |         let right = merge_sort(v[size..].to_vec());
37 |         merge(&left, &right)
38 |     };
39 | }
40 | 
41 | #[cfg(test)]
42 | mod tests {
43 |     use crate::merge_sort;
44 | 
45 |     #[test]
46 |     fn properly_sort_an_array_of_odd_length() {
47 |         assert_eq!(
48 |             merge_sort([8, 2, 5, 11, 0].to_vec()),
49 |             [0, 2, 5, 8, 11].to_vec()
50 |         );
51 |     }
52 | }
53 | 
54 | fn main() {}
55 | 


--------------------------------------------------------------------------------
/power-mod/Cargo.lock:
--------------------------------------------------------------------------------
1 | # This file is automatically @generated by Cargo.
2 | # It is not intended for manual editing.
3 | version = 3
4 | 
5 | [[package]]
6 | name = "power-mod"
7 | version = "0.1.0"
8 | 


--------------------------------------------------------------------------------
/power-mod/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "power-mod"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/power-mod/src/main.rs:
--------------------------------------------------------------------------------
 1 | fn powerMod(b: i64, e: i64, modulus: i64) -> i64 {
 2 |   if modulus == 1 {
 3 |     return 0;
 4 |   }
 5 | 
 6 |   let mut result = 1;
 7 |   let mut exponent = e;
 8 |   let mut base = b % modulus;
 9 | 
10 |   while exponent > 0 {
11 |     if exponent % 2 == 1 {
12 |       result = (result * base) % modulus;
13 |     }
14 |     exponent = exponent >> 1;
15 |     base = (base * base) % modulus;
16 |   }
17 | 
18 |   return result;
19 | }
20 | 
21 | fn main() {
22 |   println!("answer for mod 35 is {:?}", powerMod(4, 1536, 35) - powerMod(9, 4824, 35));
23 |   println!("answer for mod 37 is {:?}", powerMod(4, 1536, 37) - powerMod(9, 4824, 37));
24 | }
25 | 


--------------------------------------------------------------------------------
/prime-check/Cargo.lock:
--------------------------------------------------------------------------------
  1 | # This file is automatically @generated by Cargo.
  2 | # It is not intended for manual editing.
  3 | version = 3
  4 | 
  5 | [[package]]
  6 | name = "autocfg"
  7 | version = "1.0.1"
  8 | source = "registry+https://github.com/rust-lang/crates.io-index"
  9 | checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 10 | 
 11 | [[package]]
 12 | name = "cfg-if"
 13 | version = "1.0.0"
 14 | source = "registry+https://github.com/rust-lang/crates.io-index"
 15 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 16 | 
 17 | [[package]]
 18 | name = "getrandom"
 19 | version = "0.2.4"
 20 | source = "registry+https://github.com/rust-lang/crates.io-index"
 21 | checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c"
 22 | dependencies = [
 23 |  "cfg-if",
 24 |  "libc",
 25 |  "wasi",
 26 | ]
 27 | 
 28 | [[package]]
 29 | name = "libc"
 30 | version = "0.2.117"
 31 | source = "registry+https://github.com/rust-lang/crates.io-index"
 32 | checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"
 33 | 
 34 | [[package]]
 35 | name = "num-bigint"
 36 | version = "0.4.3"
 37 | source = "registry+https://github.com/rust-lang/crates.io-index"
 38 | checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
 39 | dependencies = [
 40 |  "autocfg",
 41 |  "num-integer",
 42 |  "num-traits",
 43 |  "rand",
 44 | ]
 45 | 
 46 | [[package]]
 47 | name = "num-integer"
 48 | version = "0.1.44"
 49 | source = "registry+https://github.com/rust-lang/crates.io-index"
 50 | checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
 51 | dependencies = [
 52 |  "autocfg",
 53 |  "num-traits",
 54 | ]
 55 | 
 56 | [[package]]
 57 | name = "num-traits"
 58 | version = "0.2.14"
 59 | source = "registry+https://github.com/rust-lang/crates.io-index"
 60 | checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
 61 | dependencies = [
 62 |  "autocfg",
 63 | ]
 64 | 
 65 | [[package]]
 66 | name = "ppv-lite86"
 67 | version = "0.2.16"
 68 | source = "registry+https://github.com/rust-lang/crates.io-index"
 69 | checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 70 | 
 71 | [[package]]
 72 | name = "prime-check"
 73 | version = "0.1.0"
 74 | dependencies = [
 75 |  "num-bigint",
 76 |  "num-traits",
 77 |  "rand",
 78 | ]
 79 | 
 80 | [[package]]
 81 | name = "rand"
 82 | version = "0.8.4"
 83 | source = "registry+https://github.com/rust-lang/crates.io-index"
 84 | checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
 85 | dependencies = [
 86 |  "libc",
 87 |  "rand_chacha",
 88 |  "rand_core",
 89 |  "rand_hc",
 90 | ]
 91 | 
 92 | [[package]]
 93 | name = "rand_chacha"
 94 | version = "0.3.1"
 95 | source = "registry+https://github.com/rust-lang/crates.io-index"
 96 | checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 97 | dependencies = [
 98 |  "ppv-lite86",
 99 |  "rand_core",
100 | ]
101 | 
102 | [[package]]
103 | name = "rand_core"
104 | version = "0.6.3"
105 | source = "registry+https://github.com/rust-lang/crates.io-index"
106 | checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
107 | dependencies = [
108 |  "getrandom",
109 | ]
110 | 
111 | [[package]]
112 | name = "rand_hc"
113 | version = "0.3.1"
114 | source = "registry+https://github.com/rust-lang/crates.io-index"
115 | checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
116 | dependencies = [
117 |  "rand_core",
118 | ]
119 | 
120 | [[package]]
121 | name = "wasi"
122 | version = "0.10.2+wasi-snapshot-preview1"
123 | source = "registry+https://github.com/rust-lang/crates.io-index"
124 | checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
125 | 


--------------------------------------------------------------------------------
/prime-check/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "prime-check"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 7 | 
 8 | [dependencies]
 9 | rand = "0.8.0"
10 | num-bigint = { version = "0.4", features = ["rand"] }
11 | num-traits = "0.2"
12 | 


--------------------------------------------------------------------------------
/prime-check/src/main.rs:
--------------------------------------------------------------------------------
 1 | use std::ops::Sub;
 2 | use std::str::FromStr;
 3 | use num_bigint::{BigUint, RandomBits, ToBigUint};
 4 | use num_traits::{Zero, One};
 5 | use rand::Rng;
 6 | 
 7 | fn gcd(a: &BigUint, b: &BigUint) -> BigUint {
 8 |   if a < b {
 9 |     gcd(b, a)
10 |   } else if a % b == BigUint::zero() {
11 |     b.to_biguint().unwrap()
12 |   } else {
13 |     gcd(b, &(a % b))
14 |   }
15 | }
16 | 
17 | fn is_prime(n: BigUint, k: u128) -> bool {
18 |   let mut size = k;
19 |   let mut rng = rand::thread_rng();
20 | 
21 |   while size > 0 {
22 |     let random: BigUint = rng.sample(RandomBits::new(256));
23 |     let a: BigUint = 2.to_biguint().unwrap() * random % n.clone();
24 | 
25 |     if gcd(&n , &a) != BigUint::one() {
26 |       return false;
27 |     }
28 | 
29 | 
30 |     if a.modpow(&n.clone().sub(BigUint::one()), &n) != BigUint::one() {
31 |       return false;
32 |     }
33 | 
34 |     size -= 1;
35 |   }
36 | 
37 |   true
38 | }
39 | 
40 | fn main() {
41 |   println!("10106665597294733930808268834911 {:?}", is_prime(BigUint::from_str("10106665597294733930808268834911").unwrap(), 128));
42 |   println!("557940830126698960967415391 {:?}", is_prime(BigUint::from_str("557940830126698960967415391").unwrap(), 128));
43 |   println!("2305567963945518424753102147331756071 {:?}", is_prime(BigUint::from_str("2305567963945518424753102147331756071").unwrap(), 128));
44 |   println!("169665573205075467667167 {:?}", is_prime(BigUint::from_str("169665573205075467667167").unwrap(), 128));
45 | }
46 | 


--------------------------------------------------------------------------------