fuzzy_fraction 0.1.2

Struct for approximated human-readable fraction representation..
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

mod structs;
pub use structs::fuzzy_fraction_function::fuzzy_fraction;
pub use structs::FuzzyFraction;
#[cfg(test)]
mod tests {
    use super::{fuzzy_fraction, FuzzyFraction};

    #[test]
    fn fuzzy_function() {
        assert_eq!(fuzzy_fraction(1, 2), fuzzy_fraction(3, 6));
        assert_eq!(fuzzy_fraction(1, 3), fuzzy_fraction(2, 6));
        assert_eq!(fuzzy_fraction(3, 1), fuzzy_fraction(6, 2));
        assert_eq!(fuzzy_fraction(4, 3), fuzzy_fraction(16, 12));
    }

    #[test]
    fn from_floats() {
        let mut ff = FuzzyFraction::from_float(0.5);
        assert_eq!(format!("{}", ff), "1/2");
        assert_eq!(ff.ratio_fmt(), "1:2");

        ff = FuzzyFraction::from_float(-1.33);
        assert_eq!(format!("{}", ff), "-1 1/3");
        assert_eq!(ff.ratio_fmt(), "4:3");
    }

    #[test]
    fn from_ints() {
        let mut ff = FuzzyFraction::from_ints(1920, 1080);
        assert_eq!(format!("{}", ff), "1 7/9");
        assert_eq!(ff.ratio_fmt(), "16:9");

        ff = FuzzyFraction::from_ints(-10, 31);
        assert_eq!(format!("{}", ff), "-1/3");
        assert_eq!(ff.ratio_fmt(), "1:3");

        ff = FuzzyFraction::from_ints(-31, 10);
        assert_eq!(format!("{}", ff), "-3");
        assert_eq!(ff.ratio_fmt(), "3:1");

        ff = FuzzyFraction::from_ints(0, -42);
        assert_eq!(format!("{}", ff), "0");
        assert_eq!(ff.ratio_fmt(), "0:1");

        ff = FuzzyFraction::from_ints(-42, 0);
        assert_eq!(format!("{}", ff), "1");
        assert_eq!(ff.ratio_fmt(), "1:0");

        assert_eq!(
            format!("{}", FuzzyFraction::from_ints(199, 99)),
            format!("{}", FuzzyFraction::from_ints(201, 100))
        );
        assert_eq!(
            format!("{}", FuzzyFraction::from_ints(-199, 0)),
            format!("{}", FuzzyFraction::from_ints(201, 0))
        );
        assert_eq!(
            format!("{}", FuzzyFraction::from_ints(0, -199)),
            format!("{}", FuzzyFraction::from_ints(0, 201))
        );
    }
}