Added faster_perfect_numbers and mersenne_primes

src/math/faster_perfect_numbers.rs

@@ -0,0 +1,40 @@
+use super::{mersenne_primes::is_mersenne_prime, prime_numbers::prime_numbers};
+use std::convert::TryInto;
+
+/*
+    Generates a list of perfect numbers till `num` using the Lucas Lehmer test algorithm.
+    url : https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
+*/
+pub fn generate_perfect_numbers(num: usize) -> Vec<usize> {
+    let mut results = Vec::new();
+    let prime_limit = get_prime_limit(num);
+
+    for i in prime_numbers(prime_limit).iter() {
+        let prime = *i;
+        if is_mersenne_prime(prime) {
+            results.push(
+                (2_usize.pow(prime.try_into().unwrap()) - 1)
+                    * (2_usize.pow((prime - 1).try_into().unwrap())),
+            );
+        }
+    }
+    results.into_iter().filter(|x| *x <= num).collect()
+}
+
+// Gets an approximate limit for the generate_perfect_numbers function
+fn get_prime_limit(num: usize) -> usize {
+    (((num * 8 + 1) as f64).log2() as usize) / 2_usize
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn perfect_numbers_till_n() {
+        let n = 335564540;
+        assert_eq!(generate_perfect_numbers(n), [6, 28, 496, 8128, 33550336]);
+        assert_eq!(generate_perfect_numbers(40), [6, 28]);
+        assert_eq!(generate_perfect_numbers(0), []);
+    }
+}

src/math/mersenne_primes.rs

@@ -0,0 +1,39 @@
+// mersenne prime : https://en.wikipedia.org/wiki/Mersenne_prime
+pub fn is_mersenne_prime(n: usize) -> bool {
+    if n == 2 {
+        return true;
+    }
+    let mut s = 4;
+    let m = 2_usize.pow(std::convert::TryInto::try_into(n).unwrap()) - 1;
+    for _ in 0..n - 2 {
+        s = ((s * s) - 2) % m;
+    }
+    s == 0
+}
+
+pub fn get_mersenne_primes(limit: usize) -> Vec<usize> {
+    let mut results: Vec<usize> = Vec::new();
+    for num in 1..=limit {
+        if is_mersenne_prime(num) {
+            results.push(num);
+        }
+    }
+    results
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{get_mersenne_primes, is_mersenne_prime};
+
+    #[test]
+    fn validity_check() {
+        assert!(is_mersenne_prime(3));
+        assert!(is_mersenne_prime(13));
+        assert!(!is_mersenne_prime(32));
+    }
+
+    #[allow(dead_code)]
+    fn generation_check() {
+        assert_eq!(get_mersenne_primes(30), [2, 3, 5, 7, 13, 17, 19]);
+    }
+}

src/math/mod.rs

@@ -3,13 +3,15 @@ mod baby_step_giant_step;
 mod extended_euclidean_algorithm;
 mod fast_fourier_transform;
 mod fast_power;
+mod faster_perfect_numbers;
 mod gaussian_elimination;
 mod gcd_of_n_numbers;
 mod greatest_common_divisor;
 mod karatsuba_multiplication;
 mod lcm_of_n_numbers;
 mod linear_sieve;
 mod matrix_ops;
+mod mersenne_primes;
 mod miller_rabin;
 mod newton_raphson;
 mod nthprime;
@@ -35,6 +37,7 @@ pub use self::fast_fourier_transform::{
     inverse_fast_fourier_transform,
 };
 pub use self::fast_power::fast_power;
+pub use self::faster_perfect_numbers::generate_perfect_numbers;
 pub use self::gaussian_elimination::gaussian_elimination;
 pub use self::gcd_of_n_numbers::gcd;
 pub use self::greatest_common_divisor::{
@@ -46,6 +49,7 @@ pub use self::linear_sieve::LinearSieve;
 pub use self::matrix_ops::{
     matrix_add, matrix_multiply, matrix_scalar_multiplication, matrix_subtract, matrix_transpose,
 };
+pub use self::mersenne_primes::{get_mersenne_primes, is_mersenne_prime};
 pub use self::miller_rabin::miller_rabin;
 pub use self::newton_raphson::find_root;
 pub use self::nthprime::nthprime;