fractions-rs 0.1.5

Fractions numbers implementation for Rust
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use super::*;

#[test]
fn test_more_special_values() {
    let zero = Fraction::new(0, 1);
    let inf = Fraction::new(1, 0);
    let neg_inf = Fraction::new(-1, 0);
    let nan = Fraction::new(0, 0);

    // Division by zero
    assert_eq!(Fraction::new(1, 1) / zero, inf);
    assert_eq!(Fraction::new(-1, 1) / zero, neg_inf);

    // NaN arithmetic
    assert!((nan + inf).is_nan());
    assert!((nan - inf).is_nan());
    assert!((nan * inf).is_nan());
    assert!((nan / inf).is_nan());
    assert!((inf + nan).is_nan());
    assert!((inf - nan).is_nan());
    assert!((inf * nan).is_nan());
    assert!((inf / nan).is_nan());
}

#[test]
fn test_extra_const_gcd() {
    assert_eq!(const_gcd(0, 0), 0);
    assert_eq!(const_gcd(1, 0), 1);
    assert_eq!(const_gcd(0, 1), 1);
    assert_eq!(const_gcd(-1, 0), 1);
    assert_eq!(const_gcd(0, -1), 1);
    assert_eq!(const_gcd(10, 20), 10);
    assert_eq!(const_gcd(-10, 20), 10);
    assert_eq!(const_gcd(10, -20), 10);
    assert_eq!(const_gcd(-10, -20), 10);
}

#[test]
fn test_extra_cross() {
    let f1 = Fraction::new(1, 2);
    let f2 = Fraction::new(3, 4);
    assert_eq!(f1.cross(&f2), -2);

    let f3 = Fraction::new(0, 1);
    assert_eq!(f1.cross(&f3), 1);

    let f4 = Fraction::new(-1, 2);
    assert_eq!(f1.cross(&f4), 4);
}

#[test]
fn test_extra_reciprocal() {
    let mut f1 = Fraction::new(2, 1);
    f1.reciprocal();
    assert_eq!(f1, Fraction::new(1, 2));

    let mut f2 = Fraction::new(1, 1);
    f2.reciprocal();
    assert_eq!(f2, Fraction::new(1, 1));

    let mut f3 = Fraction::new(10, 5);
    f3.reciprocal();
    assert_eq!(f3, Fraction::new(1, 2));
}

#[test]
fn test_extra_special_values() {
    let inf = Fraction::new(1, 0);
    let neg_inf = Fraction::new(-1, 0);

    assert!((inf + neg_inf).is_nan());
    assert!((neg_inf + inf).is_nan());

    assert!((inf / inf).is_nan());
    assert!((inf / neg_inf).is_nan());
    assert!((neg_inf / inf).is_nan());
    assert!((neg_inf / neg_inf).is_nan());

    assert!((inf * Fraction::new(0, 1)).is_nan());
    assert!((neg_inf * Fraction::new(0, 1)).is_nan());
}

#[test]
fn test_from_i32_to_i64() {
    let f_i32 = 3;
    let f_i64 = Fraction::<i64>::from(f_i32);
    assert_eq!(f_i64, Fraction::new(3i64, 1i64));
}