Merge branch 'master' into rgb_cmyk_conversion

Author: vil02

DIRECTORY.md

@@ -53,6 +53,7 @@
     * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/decimal_to_hexadecimal.rs)
     * [Hexadecimal To Binary](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/hexadecimal_to_binary.rs)
     * [Hexadecimal To Decimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/hexadecimal_to_decimal.rs)
+    * [Length Conversion](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/length_conversion.rs)
     * [Octal To Binary](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/octal_to_binary.rs)
     * [Octal To Decimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/octal_to_decimal.rs)
     * [RGB to CMYK](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/rgb_cmyk_conversion.rs)
@@ -157,6 +158,7 @@
     * [Cholesky](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/cholesky.rs)
     * [K Means](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/k_means.rs)
     * [Linear Regression](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/linear_regression.rs)
+    * [Logistic Regression](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/logistic_regression.rs)
     * Loss Function
       * [Average Margin Ranking Loss](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/loss_function/average_margin_ranking_loss.rs)
       * [Hinge Loss](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/loss_function/hinge_loss.rs)

src/conversions/length_conversion.rs

@@ -0,0 +1,94 @@
+/// Author : https://github.com/ali77gh
+/// Conversion of length units.
+///
+/// Available Units:
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Millimeter
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Centimeter
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Meter
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Kilometer
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Inch
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Foot
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Yard
+/// -> Wikipedia reference: https://en.wikipedia.org/wiki/Mile
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LengthUnit {
+    Millimeter,
+    Centimeter,
+    Meter,
+    Kilometer,
+    Inch,
+    Foot,
+    Yard,
+    Mile,
+}
+
+fn unit_to_meter_multiplier(from: LengthUnit) -> f64 {
+    match from {
+        LengthUnit::Millimeter => 0.001,
+        LengthUnit::Centimeter => 0.01,
+        LengthUnit::Meter => 1.0,
+        LengthUnit::Kilometer => 1000.0,
+        LengthUnit::Inch => 0.0254,
+        LengthUnit::Foot => 0.3048,
+        LengthUnit::Yard => 0.9144,
+        LengthUnit::Mile => 1609.34,
+    }
+}
+
+fn unit_to_meter(input: f64, from: LengthUnit) -> f64 {
+    input * unit_to_meter_multiplier(from)
+}
+
+fn meter_to_unit(input: f64, to: LengthUnit) -> f64 {
+    input / unit_to_meter_multiplier(to)
+}
+
+/// This function will convert a value in unit of [from] to value in unit of [to]
+/// by first converting it to meter and than convert it to destination unit
+pub fn length_conversion(input: f64, from: LengthUnit, to: LengthUnit) -> f64 {
+    meter_to_unit(unit_to_meter(input, from), to)
+}
+
+#[cfg(test)]
+mod length_conversion_tests {
+    use std::collections::HashMap;
+
+    use super::LengthUnit::*;
+    use super::*;
+
+    #[test]
+    fn zero_to_zero() {
+        let units = vec![
+            Millimeter, Centimeter, Meter, Kilometer, Inch, Foot, Yard, Mile,
+        ];
+
+        for u1 in units.clone() {
+            for u2 in units.clone() {
+                assert_eq!(length_conversion(0f64, u1, u2), 0f64);
+            }
+        }
+    }
+
+    #[test]
+    fn length_of_one_meter() {
+        let meter_in_different_units = HashMap::from([
+            (Millimeter, 1000f64),
+            (Centimeter, 100f64),
+            (Kilometer, 0.001f64),
+            (Inch, 39.37007874015748f64),
+            (Foot, 3.280839895013123f64),
+            (Yard, 1.0936132983377078f64),
+            (Mile, 0.0006213727366498068f64),
+        ]);
+        for (input_unit, input_value) in &meter_in_different_units {
+            for (target_unit, target_value) in &meter_in_different_units {
+                assert!(
+                    num_traits::abs(
+                        length_conversion(*input_value, *input_unit, *target_unit) - *target_value
+                    ) < 0.0000001
+                );
+            }
+        }
+    }
+}

src/conversions/mod.rs

@@ -4,6 +4,7 @@ mod decimal_to_binary;
 mod decimal_to_hexadecimal;
 mod hexadecimal_to_binary;
 mod hexadecimal_to_decimal;
+mod length_conversion;
 mod octal_to_binary;
 mod octal_to_decimal;
 mod rgb_cmyk_conversion;
@@ -13,6 +14,7 @@ pub use self::decimal_to_binary::decimal_to_binary;
 pub use self::decimal_to_hexadecimal::decimal_to_hexadecimal;
 pub use self::hexadecimal_to_binary::hexadecimal_to_binary;
 pub use self::hexadecimal_to_decimal::hexadecimal_to_decimal;
+pub use self::length_conversion::length_conversion;
 pub use self::octal_to_binary::octal_to_binary;
 pub use self::octal_to_decimal::octal_to_decimal;
 pub use self::rgb_cmyk_conversion::rgb_to_cmyk;

src/dynamic_programming/fibonacci.rs

@@ -158,7 +158,7 @@ fn matrix_multiply(multiplier: &[Vec<u128>], multiplicand: &[Vec<u128>]) -> Vec<
     // of columns as the multiplicand has rows.
     let mut result: Vec<Vec<u128>> = vec![];
     let mut temp;
-    // Using variable to compare lenghts of rows in multiplicand later
+    // Using variable to compare lengths of rows in multiplicand later
     let row_right_length = multiplicand[0].len();
     for row_left in 0..multiplier.len() {
         if multiplier[row_left].len() != multiplicand.len() {
@@ -180,6 +180,33 @@ fn matrix_multiply(multiplier: &[Vec<u128>], multiplicand: &[Vec<u128>]) -> Vec<
     result
 }
 
+/// Binary lifting fibonacci
+///
+/// Following properties of F(n) could be deduced from the matrix formula above:
+///
+/// F(2n)   = F(n) * (2F(n+1) - F(n))
+/// F(2n+1) = F(n+1)^2 + F(n)^2
+///
+/// Therefore F(n) and F(n+1) can be derived from F(n>>1) and F(n>>1 + 1), which
+/// has a smaller constant in both time and space compared to matrix fibonacci.
+pub fn binary_lifting_fibonacci(n: u32) -> u128 {
+    // the state always stores F(k), F(k+1) for some k, initially F(0), F(1)
+    let mut state = (0u128, 1u128);
+
+    for i in (0..u32::BITS - n.leading_zeros()).rev() {
+        // compute F(2k), F(2k+1) from F(k), F(k+1)
+        state = (
+            state.0 * (2 * state.1 - state.0),
+            state.0 * state.0 + state.1 * state.1,
+        );
+        if n & (1 << i) != 0 {
+            state = (state.1, state.0 + state.1);
+        }
+    }
+
+    state.0
+}
+
 /// nth_fibonacci_number_modulo_m(n, m) returns the nth fibonacci number modulo the specified m
 /// i.e. F(n) % m
 pub fn nth_fibonacci_number_modulo_m(n: i64, m: i64) -> i128 {
@@ -195,7 +222,7 @@ pub fn nth_fibonacci_number_modulo_m(n: i64, m: i64) -> i128 {
 fn get_pisano_sequence_and_period(m: i64) -> (i128, Vec<i128>) {
     let mut a = 0;
     let mut b = 1;
-    let mut lenght: i128 = 0;
+    let mut length: i128 = 0;
     let mut pisano_sequence: Vec<i128> = vec![a, b];
 
     // Iterating through all the fib numbers to get the sequence
@@ -213,12 +240,12 @@ fn get_pisano_sequence_and_period(m: i64) -> (i128, Vec<i128>) {
             // This is a less elegant way to do it.
             pisano_sequence.pop();
             pisano_sequence.pop();
-            lenght = pisano_sequence.len() as i128;
+            length = pisano_sequence.len() as i128;
             break;
         }
     }
 
-    (lenght, pisano_sequence)
+    (length, pisano_sequence)
 }
 
 /// last_digit_of_the_sum_of_nth_fibonacci_number(n) returns the last digit of the sum of n fibonacci numbers.
@@ -251,6 +278,7 @@ pub fn last_digit_of_the_sum_of_nth_fibonacci_number(n: i64) -> i64 {
 
 #[cfg(test)]
 mod tests {
+    use super::binary_lifting_fibonacci;
     use super::classical_fibonacci;
     use super::fibonacci;
     use super::last_digit_of_the_sum_of_nth_fibonacci_number;
@@ -328,7 +356,7 @@ mod tests {
     }
 
     #[test]
-    /// Check that the itterative and recursive fibonacci
+    /// Check that the iterative and recursive fibonacci
     /// produce the same value. Both are combinatorial ( F(0) = F(1) = 1 )
     fn test_iterative_and_recursive_equivalence() {
         assert_eq!(fibonacci(0), recursive_fibonacci(0));
@@ -398,6 +426,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_binary_lifting_fibonacci() {
+        assert_eq!(binary_lifting_fibonacci(0), 0);
+        assert_eq!(binary_lifting_fibonacci(1), 1);
+        assert_eq!(binary_lifting_fibonacci(2), 1);
+        assert_eq!(binary_lifting_fibonacci(3), 2);
+        assert_eq!(binary_lifting_fibonacci(4), 3);
+        assert_eq!(binary_lifting_fibonacci(5), 5);
+        assert_eq!(binary_lifting_fibonacci(10), 55);
+        assert_eq!(binary_lifting_fibonacci(20), 6765);
+        assert_eq!(binary_lifting_fibonacci(21), 10946);
+        assert_eq!(binary_lifting_fibonacci(100), 354224848179261915075);
+        assert_eq!(
+            binary_lifting_fibonacci(184),
+            127127879743834334146972278486287885163
+        );
+    }
+
     #[test]
     fn test_nth_fibonacci_number_modulo_m() {
         assert_eq!(nth_fibonacci_number_modulo_m(5, 10), 5);

src/dynamic_programming/is_subsequence.rs

@@ -1,33 +1,71 @@
-// Given two strings str1 and str2, return true if str1 is a subsequence of str2, or false otherwise.
-// A subsequence of a string is a new string that is formed from the original string
-// by deleting some (can be none) of the characters without disturbing the relative
-// positions of the remaining characters.
-// (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
-pub fn is_subsequence(str1: &str, str2: &str) -> bool {
-    let mut it1 = 0;
-    let mut it2 = 0;
+//! A module for checking if one string is a subsequence of another string.
+//!
+//! A subsequence is formed by deleting some (can be none) of the characters
+//! from the original string without disturbing the relative positions of the
+//! remaining characters. This module provides a function to determine if
+//! a given string is a subsequence of another string.
 
-    let byte1 = str1.as_bytes();
-    let byte2 = str2.as_bytes();
+/// Checks if `sub` is a subsequence of `main`.
+///
+/// # Arguments
+///
+/// * `sub` - A string slice that may be a subsequence.
+/// * `main` - A string slice that is checked against.
+///
+/// # Returns
+///
+/// Returns `true` if `sub` is a subsequence of `main`, otherwise returns `false`.
+pub fn is_subsequence(sub: &str, main: &str) -> bool {
+    let mut sub_iter = sub.chars().peekable();
+    let mut main_iter = main.chars();
 
-    while it1 < str1.len() && it2 < str2.len() {
-        if byte1[it1] == byte2[it2] {
-            it1 += 1;
+    while let Some(&sub_char) = sub_iter.peek() {
+        match main_iter.next() {
+            Some(main_char) if main_char == sub_char => {
+                sub_iter.next();
+            }
+            None => return false,
+            _ => {}
         }
-
-        it2 += 1;
     }
 
-    it1 == str1.len()
+    true
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn test() {
-        assert!(is_subsequence("abc", "ahbgdc"));
-        assert!(!is_subsequence("axc", "ahbgdc"));
+    macro_rules! subsequence_tests {
+        ($($name:ident: $test_case:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (sub, main, expected) = $test_case;
+                    assert_eq!(is_subsequence(sub, main), expected);
+                }
+            )*
+        };
+    }
+
+    subsequence_tests! {
+        test_empty_subsequence: ("", "ahbgdc", true),
+        test_empty_strings: ("", "", true),
+        test_non_empty_sub_empty_main: ("abc", "", false),
+        test_subsequence_found: ("abc", "ahbgdc", true),
+        test_subsequence_not_found: ("axc", "ahbgdc", false),
+        test_longer_sub: ("abcd", "abc", false),
+        test_single_character_match: ("a", "ahbgdc", true),
+        test_single_character_not_match: ("x", "ahbgdc", false),
+        test_subsequence_at_start: ("abc", "abchello", true),
+        test_subsequence_at_end: ("cde", "abcde", true),
+        test_same_characters: ("aaa", "aaaaa", true),
+        test_interspersed_subsequence: ("ace", "abcde", true),
+        test_different_chars_in_subsequence: ("aceg", "abcdef", false),
+        test_single_character_in_main_not_match: ("a", "b", false),
+        test_single_character_in_main_match: ("b", "b", true),
+        test_subsequence_with_special_chars: ("a1!c", "a1!bcd", true),
+        test_case_sensitive: ("aBc", "abc", false),
+        test_subsequence_with_whitespace: ("hello world", "h e l l o   w o r l d", true),
     }
 }

src/dynamic_programming/mod.rs

@@ -20,6 +20,7 @@ mod word_break;
 
 pub use self::coin_change::coin_change;
 pub use self::egg_dropping::egg_drop;
+pub use self::fibonacci::binary_lifting_fibonacci;
 pub use self::fibonacci::classical_fibonacci;
 pub use self::fibonacci::fibonacci;
 pub use self::fibonacci::last_digit_of_the_sum_of_nth_fibonacci_number;