//! # Rusty Fib Facts
//!
//! Implementations of common algorithms to benchmark
#![forbid(unsafe_code)]

mod gcd;
pub mod parallel;
pub mod factorial;
pub mod fibonacci;


pub use gcd::UnsignedGCD;
pub use factorial::*;
pub use fibonacci::*;



#[cfg(test)]
#[cfg(not(tarpaulin_include))]
mod tests {
    use super::*;

    #[test]
    fn test_factorial() {
        for pair in [[1usize, 0], [1, 1], [2, 2], [6, 3]].iter() {
            assert_eq!(
                Some(pair[0] as u128),
                factorial(pair[1]),
                "{}! should be {}",
                pair[1],
                pair[0]
            );
            assert_eq!(
                Some(pair[0] as u128),
                it_factorial(pair[1]),
                "{}! should be {}",
                pair[1],
                pair[0]
            );
        }

        // Verify each implementation returns the same results
        let res = factorial(34);
        let res2 = it_factorial(34);
        assert!(res.is_some());
        assert!(res2.is_some());
        assert_eq!(res, res2);

        // Bounds checks
        assert!(factorial(35).is_none());
        assert!(it_factorial(35).is_none());
    }

    #[test]
    fn test_approx_factorial() {
        assert!(approx_factorial(170.624).is_some());
        assert!(approx_factorial(1.0).is_some());
        assert!(approx_factorial(170.7).is_none());
    }

    #[test]
    fn test_fibonacci() {
        // Sanity checking
        for pair in [[0usize, 0], [1, 1], [1, 2], [2, 3]].iter() {
            assert_eq!(
                Some(pair[0] as u128),
                fibonacci(pair[1]),
                "fibonacci({}) should be {}",
                pair[1],
                pair[0]
            );
            assert_eq!(
                Some(pair[0] as u128),
                mem_fibonacci(pair[1]),
                "fibonacci({}) should be {}",
                pair[1],
                pair[0]
            );
            assert_eq!(
                Some(pair[0] as u128),
                rec_fibonacci(pair[1]),
                "fibonacci({}) should be {}",
                pair[1],
                pair[0]
            );
        }

        // Verify each implementation returns the same results
        let res = fibonacci(186);
        let res2 = mem_fibonacci(186);
        assert!(res.is_some());
        assert!(res2.is_some());
        assert_eq!(res, res2);

        // Bounds checks
        assert!(fibonacci(187).is_none());
        assert!(mem_fibonacci(187).is_none());
    }

    #[test]
    fn test_gcd() {
        assert_eq!(u8::gcd(5, 0), 5);
        assert_eq!(u8::gcd(0, 5), 5);
        assert_eq!(u8::gcd(2, 3), 1);
        assert_eq!(u8::gcd(2, 2), 2);
        assert_eq!(u8::gcd(2, 8), 2);
        assert_eq!(u16::gcd(36, 48), 12);
        assert_eq!(u16::e_gcd(36, 48), 12);
        assert_eq!(u16::stein_gcd(36, 48), 12);
    }

    #[test]
    fn test_lcm() {
        assert_eq!(u32::lcm(2, 8), 8);
        assert_eq!(u16::lcm(2, 3), 6);
        assert_eq!(usize::lcm(15, 30), 30);
        assert_eq!(u128::lcm(1, 5), 5);
        assert_eq!(0u8, u8::lcm(0, 0));
    }
}