Merge branch 'master' into ref/ds/segment_tree

Author: vil02

DIRECTORY.md

@@ -53,8 +53,10 @@
     * [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 Cmyk Conversion](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/rgb_cmyk_conversion.rs)
   * Data Structures
     * [Avl Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/avl_tree.rs)
     * [B Tree](https://github.com/TheAlgorithms/Rust/blob/master/src/data_structures/b_tree.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,13 +4,17 @@ 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;
 pub use self::binary_to_decimal::binary_to_decimal;
 pub use self::binary_to_hexadecimal::binary_to_hexadecimal;
 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/conversions/rgb_cmyk_conversion.rs

@@ -0,0 +1,60 @@
+/// Author : https://github.com/ali77gh\
+/// References:\
+/// RGB:  https://en.wikipedia.org/wiki/RGB_color_model\
+/// CMYK: https://en.wikipedia.org/wiki/CMYK_color_model\
+
+/// This function Converts RGB to CMYK format
+///
+/// ### Params
+/// * `r` - red
+/// * `g` - green
+/// * `b` - blue
+///
+/// ### Returns
+/// (C, M, Y, K)
+pub fn rgb_to_cmyk(rgb: (u8, u8, u8)) -> (u8, u8, u8, u8) {
+    // Safety: no need to check if input is positive and less than 255 because it's u8
+
+    // change scale from [0,255] to [0,1]
+    let (r, g, b) = (
+        rgb.0 as f64 / 255f64,
+        rgb.1 as f64 / 255f64,
+        rgb.2 as f64 / 255f64,
+    );
+
+    match 1f64 - r.max(g).max(b) {
+        1f64 => (0, 0, 0, 100), // pure black
+        k => (
+            (100f64 * (1f64 - r - k) / (1f64 - k)) as u8, // c
+            (100f64 * (1f64 - g - k) / (1f64 - k)) as u8, // m
+            (100f64 * (1f64 - b - k) / (1f64 - k)) as u8, // y
+            (100f64 * k) as u8,                           // k
+        ),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! test_rgb_to_cmyk {
+        ($($name:ident: $tc:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (rgb, cmyk) = $tc;
+                    assert_eq!(rgb_to_cmyk(rgb), cmyk);
+                }
+            )*
+        }
+    }
+
+    test_rgb_to_cmyk! {
+        white: ((255, 255, 255), (0, 0, 0, 0)),
+        gray: ((128, 128, 128), (0, 0, 0, 49)),
+        black: ((0, 0, 0), (0, 0, 0, 100)),
+        red: ((255, 0, 0), (0, 100, 100, 0)),
+        green: ((0, 255, 0), (100, 0, 100, 0)),
+        blue: ((0, 0, 255), (100, 100, 0, 0)),
+    }
+}

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/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;