Add Sum of Geometric Progression (TheAlgorithms#597)

Author: cyrixninja

DIRECTORY.md

@@ -172,6 +172,7 @@
     * [Gaussian Elimination](https://github.com/TheAlgorithms/Rust/blob/master/src/math/gaussian_elimination.rs)
     * [Gaussian Error Linear Unit](https://github.com/TheAlgorithms/Rust/blob/master/src/math/gaussian_error_linear_unit.rs)
     * [Gcd Of N Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/gcd_of_n_numbers.rs)
+    * [Geometric Series](https://github.com/TheAlgorithms/Rust/blob/master/src/math/geometric_series.rs)
     * [Greatest Common Divisor](https://github.com/TheAlgorithms/Rust/blob/master/src/math/greatest_common_divisor.rs)
     * [Huber Loss](https://github.com/TheAlgorithms/Rust/blob/master/src/math/huber_loss.rs)
     * [Interest](https://github.com/TheAlgorithms/Rust/blob/master/src/math/interest.rs)
@@ -187,6 +188,7 @@
     * [Nthprime](https://github.com/TheAlgorithms/Rust/blob/master/src/math/nthprime.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)
+    * [Perfect Square](https://github.com/TheAlgorithms/Rust/blob/master/src/math/perfect_square.rs)
     * [Pollard Rho](https://github.com/TheAlgorithms/Rust/blob/master/src/math/pollard_rho.rs)
     * [Prime Check](https://github.com/TheAlgorithms/Rust/blob/master/src/math/prime_check.rs)
     * [Prime Factors](https://github.com/TheAlgorithms/Rust/blob/master/src/math/prime_factors.rs)
@@ -204,6 +206,7 @@
     * [Square Pyramidal Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_pyramidal_numbers.rs)
     * [Square Root](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_root.rs)
     * [Sum Of Digits](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_digits.rs)
+    * [Sum Of Geometric Progression](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_geometric_progression.rs)
     * [Tanh](https://github.com/TheAlgorithms/Rust/blob/master/src/math/tanh.rs)
     * [Trial Division](https://github.com/TheAlgorithms/Rust/blob/master/src/math/trial_division.rs)
     * [Vector Cross Product](https://github.com/TheAlgorithms/Rust/blob/master/src/math/vector_cross_product.rs)

src/math/geometric_series.rs

@@ -2,7 +2,7 @@
 // Wikipedia : https://en.wikipedia.org/wiki/Geometric_series
 // Calculate a geometric series.
 
-fn geometric_series(nth_term: f64, start_term_a: f64, common_ratio_r: f64) -> Vec<f64> {
+pub fn geometric_series(nth_term: f64, start_term_a: f64, common_ratio_r: f64) -> Vec<f64> {
     let mut series = Vec::new();
     let mut multiple = 1.0;
 
@@ -14,19 +14,13 @@ fn geometric_series(nth_term: f64, start_term_a: f64, common_ratio_r: f64) -> Ve
     series
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     fn assert_approx_eq(a: f64, b: f64) {
         let epsilon = 1e-10;
-        assert!(
-            (a - b).abs() < epsilon,
-            "Expected {}, found {}",
-            a,
-            b
-        );
+        assert!((a - b).abs() < epsilon, "Expected {}, found {}", a, b);
     }
 
     #[test]
@@ -51,6 +45,5 @@ mod tests {
         assert_approx_eq(result[1], -4.0);
         assert_approx_eq(result[2], -8.0);
         assert_approx_eq(result[3], -16.0);
-
     }
 }

src/math/mod.rs

@@ -27,6 +27,7 @@ mod frizzy_number;
 mod gaussian_elimination;
 mod gaussian_error_linear_unit;
 mod gcd_of_n_numbers;
+mod geometric_series;
 mod greatest_common_divisor;
 mod huber_loss;
 mod interest;
@@ -42,6 +43,7 @@ mod newton_raphson;
 mod nthprime;
 mod pascal_triangle;
 mod perfect_numbers;
+mod perfect_square;
 mod pollard_rho;
 mod prime_check;
 mod prime_factors;
@@ -59,6 +61,7 @@ mod sprague_grundy_theorem;
 mod square_pyramidal_numbers;
 mod square_root;
 mod sum_of_digits;
+mod sum_of_geometric_progression;
 mod tanh;
 mod trial_division;
 mod vector_cross_product;
@@ -96,6 +99,7 @@ pub use self::frizzy_number::get_nth_frizzy;
 pub use self::gaussian_elimination::gaussian_elimination;
 pub use self::gaussian_error_linear_unit::gaussian_error_linear_unit;
 pub use self::gcd_of_n_numbers::gcd;
+pub use self::geometric_series::geometric_series;
 pub use self::greatest_common_divisor::{
     greatest_common_divisor_iterative, greatest_common_divisor_recursive,
     greatest_common_divisor_stein,
@@ -114,6 +118,8 @@ pub use self::newton_raphson::find_root;
 pub use self::nthprime::nthprime;
 pub use self::pascal_triangle::pascal_triangle;
 pub use self::perfect_numbers::perfect_numbers;
+pub use self::perfect_square::perfect_square;
+pub use self::perfect_square::perfect_square_binary_search;
 pub use self::pollard_rho::{pollard_rho_factorize, pollard_rho_get_one_factor};
 pub use self::prime_check::prime_check;
 pub use self::prime_factors::prime_factors;
@@ -131,6 +137,7 @@ pub use self::sprague_grundy_theorem::calculate_grundy_number;
 pub use self::square_pyramidal_numbers::square_pyramidal_number;
 pub use self::square_root::{fast_inv_sqrt, square_root};
 pub use self::sum_of_digits::{sum_digits_iterative, sum_digits_recursive};
+pub use self::sum_of_geometric_progression::sum_of_geometric_progression;
 pub use self::tanh::tanh;
 pub use self::trial_division::trial_division;
 pub use self::vector_cross_product::cross_product;

src/math/perfect_square.rs

@@ -1,32 +1,30 @@
 // Author : cyrixninja
 // Perfect Square : Checks if a number is perfect square number or not
 // https://en.wikipedia.org/wiki/Perfect_square
-fn perfect_square(num: i32) -> bool {
+pub fn perfect_square(num: i32) -> bool {
     if num < 0 {
         return false;
     }
     let sqrt_num = (num as f64).sqrt() as i32;
     sqrt_num * sqrt_num == num
 }
 
-fn perfect_square_binary_search(n: i32) -> bool {
+pub fn perfect_square_binary_search(n: i32) -> bool {
     if n < 0 {
         return false;
     }
 
     let mut left = 0;
     let mut right = n;
-    
+
     while left <= right {
         let mid = (left + right) / 2;
         let mid_squared = mid * mid;
 
-        if mid_squared == n {
-            return true;
-        } else if mid_squared > n {
-            right = mid - 1;
-        } else {
-            left = mid + 1;
+        match mid_squared.cmp(&n) {
+            std::cmp::Ordering::Equal => return true,
+            std::cmp::Ordering::Greater => right = mid - 1,
+            std::cmp::Ordering::Less => left = mid + 1,
         }
     }
 
@@ -39,21 +37,21 @@ mod tests {
 
     #[test]
     fn test_perfect_square() {
-        assert!(perfect_square(9) == true);
-        assert!(perfect_square(81) == true);
-        assert!(perfect_square(4) == true);
-        assert!(perfect_square(0) == true);
-        assert!(perfect_square(3) == false);
-        assert!(perfect_square(-19) == false);
+        assert!(perfect_square(9));
+        assert!(perfect_square(81));
+        assert!(perfect_square(4));
+        assert!(perfect_square(0));
+        assert!(!perfect_square(3));
+        assert!(!perfect_square(-19));
     }
 
     #[test]
     fn test_perfect_square_binary_search() {
-        assert!(perfect_square_binary_search(9) == true);
-        assert!(perfect_square_binary_search(81) == true);
-        assert!(perfect_square_binary_search(4) == true);
-        assert!(perfect_square_binary_search(0) == true);
-        assert!(perfect_square_binary_search(3) == false);
-        assert!(perfect_square_binary_search(-19) == false);
+        assert!(perfect_square_binary_search(9));
+        assert!(perfect_square_binary_search(81));
+        assert!(perfect_square_binary_search(4));
+        assert!(perfect_square_binary_search(0));
+        assert!(!perfect_square_binary_search(3));
+        assert!(!perfect_square_binary_search(-19));
     }
 }

src/math/sum_of_geometric_progression.rs

@@ -0,0 +1,30 @@
+// Author : cyrixninja
+// Find the Sum of Geometric Progression
+// Wikipedia: https://en.wikipedia.org/wiki/Geometric_progression
+
+pub fn sum_of_geometric_progression(first_term: f64, common_ratio: f64, num_of_terms: i32) -> f64 {
+    if common_ratio == 1.0 {
+        // Formula for sum if the common ratio is 1
+        return (num_of_terms as f64) * first_term;
+    }
+
+    // Formula for finding the sum of n terms of a Geometric Progression
+    (first_term / (1.0 - common_ratio)) * (1.0 - common_ratio.powi(num_of_terms))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sum_of_geometric_progression() {
+        let result_1 = sum_of_geometric_progression(1.0, 2.0, 10);
+        assert_eq!(result_1, 1023.0);
+
+        let result_2 = sum_of_geometric_progression(1.0, 10.0, 5);
+        assert_eq!(result_2, 11111.0);
+
+        let result_3 = sum_of_geometric_progression(9.0, 2.5, 5);
+        assert_eq!(result_3, 579.9375);
+    }
+}