g_math 0.4.2

Multi-domain fixed-point arithmetic with geometric extension: Lie groups, manifolds, ODE solvers, tensors, fiber bundles — zero-float, 0 ULP transcendentals
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

//! Integration test for symbolic rational arithmetic

#[cfg(test)]
mod integration_tests {
    use crate::fixed_point::domains::symbolic::rational::*;

    #[test]
    fn test_symbolic_integration_basic() {
        // Create rational numbers
        let a = RationalNumber::new(1, 3);  // 1/3
        let b = RationalNumber::new(3, 8);  // 3/8
        
        // Test division-as-multiplication: (1/3) ÷ (3/8) = 8/9
        let result = a / b;
        
        // Verify exact result
        assert_eq!(result.numerator_i128().unwrap(), 8);
        assert_eq!(result.denominator_i128().unwrap(), 9);
    }
    
    #[test]
    fn test_rational_mathematical_exactness() {
        // Test perfect precision: (1/3) * 3 = 1 exactly
        let one_third = RationalNumber::new(1, 3);
        let three = RationalNumber::new(3, 1);
        let result = one_third * three;
        
        // Should be exactly 1/1
        assert_eq!(result.numerator_i128().unwrap(), 1);
        assert_eq!(result.denominator_i128().unwrap(), 1);
    }
    
    #[test]
    fn test_rational_chain_operations() {
        // Complex chain: ((1/7) × (7/3)) ÷ (2/9) = (1/3) × (9/2) = 9/6 = 3/2
        let a = RationalNumber::new(1, 7);
        let b = RationalNumber::new(7, 3);  
        let c = RationalNumber::new(2, 9);
        
        let result = (a * b) / c;
        
        // Should simplify to 3/2 after GCD reduction
        // Note: We might get 9/6 which is equivalent, but our implementation
        // should canonicalize it to 3/2
        let expected_num = 3i32;
        let expected_den = 2i32;
        
        // Check the mathematical equivalence
        let actual_num: i32 = result.numerator_i128().unwrap() as i32;
        let actual_den: i32 = result.denominator_i128().unwrap() as i32;
        
        // Cross multiply to check equality: actual_num * expected_den == expected_num * actual_den
        assert_eq!(actual_num * expected_den, expected_num * actual_den);
    }
}