Add simple math algorithms (TheAlgorithms#251)

Author: donbarbos

CONTRIBUTING.md

@@ -43,8 +43,9 @@ mod tests {
 
 Do **not** use acronyms: `DFS` should be `depth_first_search`.
 
-Make sure you ran
+Make sure you run
   * `cargo test` 
   * `cargo fmt`
-  
+  * `cargo clippy`
+
   And that's about it !

DIRECTORY.md

@@ -51,6 +51,10 @@
   * Math
     * [Extended Euclidean Algorithm](https://github.com/TheAlgorithms/Rust/blob/master/src/math/extended_euclidean_algorithm.rs)
     * [Pascal Triangle](https://github.com/TheAlgorithms/Rust/blob/master/src/math/pascal_triangle.rs)
+    * [Perfect Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/perfect_numbers.rs)
+    * [Prime Check](https://github.com/TheAlgorithms/Rust/blob/master/src/math/prime_check.rs)
+    * [Prime Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/prime_numbers.rs)
+    * [Trial Division](https://github.com/TheAlgorithms/Rust/blob/master/src/math/trial_division.rs)
   * Searching
     * [Binary Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/binary_search.rs)
     * [Binary Search Recursive](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/binary_search_recursive.rs)

src/math/mod.rs

@@ -1,5 +1,13 @@
 mod extended_euclidean_algorithm;
 mod pascal_triangle;
+mod perfect_numbers;
+mod prime_check;
+mod prime_numbers;
+mod trial_division;
 
 pub use self::extended_euclidean_algorithm::extended_euclidean_algorithm;
 pub use self::pascal_triangle::pascal_triangle;
+pub use self::perfect_numbers::perfect_numbers;
+pub use self::prime_check::prime_check;
+pub use self::prime_numbers::prime_numbers;
+pub use self::trial_division::trial_division;

src/math/perfect_numbers.rs

@@ -0,0 +1,47 @@
+pub fn is_perfect_number(num: usize) -> bool {
+    let mut sum = 0;
+
+    for i in 1..num - 1 {
+        if num % i == 0 {
+            sum += i;
+        }
+    }
+
+    num == sum
+}
+
+pub fn perfect_numbers(max: usize) -> Vec<usize> {
+    let mut result: Vec<usize> = Vec::new();
+
+    // It is not known if there are any odd perfect numbers, so we go around all the numbers.
+    for i in 1..max + 1 {
+        if is_perfect_number(i) {
+            result.push(i);
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic() {
+        assert_eq!(is_perfect_number(6), true);
+        assert_eq!(is_perfect_number(28), true);
+        assert_eq!(is_perfect_number(496), true);
+        assert_eq!(is_perfect_number(8128), true);
+
+        assert_eq!(is_perfect_number(5), false);
+        assert_eq!(is_perfect_number(86), false);
+        assert_eq!(is_perfect_number(497), false);
+        assert_eq!(is_perfect_number(8120), false);
+
+        assert_eq!(perfect_numbers(10), vec![6]);
+        assert_eq!(perfect_numbers(100), vec![6, 28]);
+        assert_eq!(perfect_numbers(496), vec![6, 28, 496]);
+        assert_eq!(perfect_numbers(1000), vec![6, 28, 496]);
+    }
+}

src/math/prime_check.rs

@@ -0,0 +1,33 @@
+pub fn prime_check(num: usize) -> bool {
+    if (num > 1) & (num < 4) {
+        return true;
+    } else if (num < 2) || (num % 2 == 0) {
+        return false;
+    }
+
+    let stop: usize = (num as f64).sqrt() as usize + 1;
+    for i in (3..stop).step_by(2) {
+        if num % i == 0 {
+            return false;
+        }
+    }
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic() {
+        assert_eq!(prime_check(3), true);
+        assert_eq!(prime_check(7), true);
+        assert_eq!(prime_check(11), true);
+        assert_eq!(prime_check(2003), true);
+
+        assert_eq!(prime_check(4), false);
+        assert_eq!(prime_check(6), false);
+        assert_eq!(prime_check(21), false);
+        assert_eq!(prime_check(2004), false);
+    }
+}

src/math/prime_numbers.rs

@@ -0,0 +1,38 @@
+pub fn prime_numbers(max: usize) -> Vec<usize> {
+    let mut result: Vec<usize> = Vec::new();
+
+    if max >= 2 {
+        result.push(2)
+    }
+    for i in (3..max + 1).step_by(2) {
+        let stop: usize = (i as f64).sqrt() as usize + 1;
+        let mut status: bool = true;
+
+        for j in (3..stop).step_by(2) {
+            if i % j == 0 {
+                status = false
+            }
+        }
+        if status {
+            result.push(i)
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic() {
+        assert_eq!(prime_numbers(0), vec![]);
+        assert_eq!(prime_numbers(11), vec![2, 3, 5, 7, 11]);
+        assert_eq!(prime_numbers(25), vec![2, 3, 5, 7, 11, 13, 17, 19, 23]);
+        assert_eq!(
+            prime_numbers(33),
+            vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
+        );
+    }
+}

src/math/trial_division.rs

@@ -0,0 +1,49 @@
+fn floor(value: f64, scale: u8) -> f64 {
+    let multiplier = 10i64.pow(scale as u32) as f64;
+    (value * multiplier).floor()
+}
+
+fn double_to_int(amount: f64) -> i128 {
+    amount.round() as i128
+}
+
+pub fn trial_division(mut num: i128) -> Vec<i128> {
+    let mut result: Vec<i128> = vec![];
+
+    while num % 2 == 0 {
+        result.push(2);
+        num /= 2;
+        num = double_to_int(floor(num as f64, 0))
+    }
+    let mut f: i128 = 3;
+
+    while f.pow(2) <= num {
+        if num % f == 0 {
+            result.push(f);
+            num /= f;
+            num = double_to_int(floor(num as f64, 0))
+        } else {
+            f += 2
+        }
+    }
+
+    if num != 1 {
+        result.push(num)
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic() {
+        assert_eq!(trial_division(9), vec!(3, 3));
+        assert_eq!(trial_division(10), vec!(2, 5));
+        assert_eq!(trial_division(11), vec!(11));
+        assert_eq!(trial_division(33), vec!(3, 11));
+        assert_eq!(trial_division(2003), vec!(2003));
+        assert_eq!(trial_division(100001), vec!(11, 9091));
+    }
+}