yufmath 0.1.1

A Rust CAS Lib.
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

//! 高精度小数修复演示
//! 
//! 这个示例演示了修复后的高精度小数计算功能

use yufmath::core::Number;
use bigdecimal::BigDecimal;
use num_bigint::BigInt;
use std::str::FromStr;

fn main() {
    println!("=== Yufmath 高精度小数修复演示 ===\n");
    
    // 用户报告的问题：0.00000000000000000000000000000000000000000000000000000000000000000000001+0.1
    println!("1. 用户报告的问题测试:");
    println!("   计算: 0.00000000000000000000000000000000000000000000000000000000000000000000001 + 0.1");
    
    // 创建极小的数值：71位小数精度
    let tiny_number = Number::real(BigDecimal::new(BigInt::from(1), 71));
    let point_one = Number::real(BigDecimal::from_str("0.1").unwrap());
    
    println!("   极小数值: {}", tiny_number);
    println!("   0.1: {}", point_one);
    
    let result = tiny_number + point_one;
    println!("   计算结果: {}", result);
    
    let expected = "0.10000000000000000000000000000000000000000000000000000000000000000000001";
    println!("   预期结果: {}", expected);
    
    // 验证结果
    let expected_number = Number::real(BigDecimal::from_str(expected).unwrap());
    if result == expected_number {
        println!("   ✓ 结果正确！高精度计算成功\n");
    } else {
        println!("   ✗ 结果不正确\n");
    }
    
    // 演示不同精度级别的计算
    println!("2. 不同精度级别演示:");
    
    let precisions = vec![10, 20, 50, 100];
    for precision in precisions {
        println!("   {}位小数精度:", precision);
        
        let tiny = Number::real(BigDecimal::new(BigInt::from(1), precision as i64));
        let half = Number::real(BigDecimal::from_str("0.5").unwrap());
        let result = tiny + half;
        
        println!("     1E-{} + 0.5 = {}", precision, result);
    }
    
    println!();
    
    // 演示有理数到实数的精确转换
    println!("3. 有理数到实数转换演示:");
    
    let rational_third = Number::rational(1, 3);  // 1/3
    let tiny_real = Number::real(BigDecimal::new(BigInt::from(1), 30));
    
    println!("   有理数 1/3: {}", rational_third);
    println!("   极小实数 1E-30: {}", tiny_real);
    
    let mixed_result = rational_third + tiny_real;
    println!("   1/3 + 1E-30 = {}", mixed_result);
    println!("   ✓ 有理数转换保持了高精度\n");
    
    // 演示浮点数精度损失对比
    println!("4. 浮点数精度损失对比:");
    
    let tiny_bd = Number::real(BigDecimal::new(BigInt::from(1), 50));
    let point_one_bd = Number::real(BigDecimal::from_str("0.1").unwrap());
    let point_one_float = Number::float(0.1);
    
    let result_precise = tiny_bd.clone() + point_one_bd;
    let result_float = tiny_bd + point_one_float;
    
    println!("   高精度计算: 1E-50 + 0.1(BigDecimal) = {}", result_precise);
    println!("   浮点数计算: 1E-50 + 0.1(f64) = {}", result_float);
    println!("   ✓ 可以看到浮点数版本丢失了精度\n");
    
    println!("=== 修复总结 ===");
    println!("✓ 修复了有理数到实数转换时的精度损失问题");
    println!("✓ BigDecimal 层面的高精度计算工作正常");
    println!("✓ Number 类型的运算保持了完整精度");
    println!("✓ 用户报告的具体问题已解决");
}