gy_r_number 0.1.0

A Rust library for handling rational numbers with high precision.
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

use gy_r_number::*;

fn main() {
    println!("=== Number 类型基本使用示例 ===");

    // 创建不同类型的数字
    let int_num = Number::from(42);
    let big_num = Number::from_big_int_str("999999999999999999999999999999", 10);
    let rational = Number::from_rational(
        num_bigint::BigInt::from(22), 
        num_bigint::BigInt::from(7)
    ); // 22/7 近似π
    let float_num = Number::from(3.14159);

    println!("整数: {}", int_num);
    println!("大整数: {}", big_num);
    println!("有理数: {} (分数表示: {})", rational, rational.to_fraction_string());
    println!("浮点数: {}", float_num);

    // 基本运算
    println!("\n=== 基本运算 ===");
    let a = Number::from(10);
    let b = Number::from(3);
    
    println!("{} + {} = {}", a, b, a.clone() + b.clone());
    println!("{} - {} = {}", a, b, a.clone() - b.clone());
    println!("{} * {} = {}", a, b, a.clone() * b.clone());
    println!("{} / {} = {}", a, b, a.clone() / b.clone());

    // 数学函数
    println!("\n=== 数学函数 ===");
    let num = Number::from(16);
    println!("sqrt({}) = {}", num, num.sqrt());
    println!("abs({}) = {}", Number::from(-5), Number::from(-5).abs());
    println!("pow({}, 2) = {}", Number::from(3), Number::from(3).pow(&Number::from(2)));

    // 类型转换和错误处理
    println!("\n=== 类型转换 ===");
    
    // 成功转换
    let small_num = Number::from(42);
    match small_num.try_to::<i32>() {
        Ok(value) => println!("成功转换为 i32: {}", value),
        Err(error) => println!("转换失败: {}", error),
    }

    // 失败转换与后备策略
    let big_number = Number::from_big_int_str("999999999999999999999999999999", 10);
    
    // 使用零值后备
    let zero_fallback: i32 = big_number.unwrap_or_lossy();
    println!("大数转换为 i32 (零值后备): {}", zero_fallback);
    
    // 使用饱和转换
    let saturated: i32 = big_number.unwrap_saturating();
    println!("大数转换为 i32 (饱和转换): {}", saturated);
    
    // 使用自定义后备值
    let custom: i32 = big_number.unwrap_or(-1);
    println!("大数转换为 i32 (自定义后备): {}", custom);

    // 带详细信息的转换
    println!("\n=== 带警告的转换 ===");
    let _with_warning: i32 = big_number.unwrap_with_warning(FallbackValue::Zero);

    // 字符串解析
    println!("\n=== 字符串解析 ===");
    let parsed_int = Number::parse_int("12345", Some(10));
    let parsed_hex = Number::parse_int("FF", Some(16));
    let parsed_float = Number::parse_float("3.14159");
    
    println!("解析整数 '12345': {}", parsed_int);
    println!("解析十六进制 'FF': {}", parsed_hex);
    println!("解析浮点数 '3.14159': {}", parsed_float);

    // 内存使用情况
    println!("\n=== 内存使用情况 ===");
    println!("小整数内存使用: {} 字节", int_num.memory_size());
    println!("大整数内存使用: {} 字节", big_num.memory_size());
    println!("有理数内存使用: {} 字节", rational.memory_size());
    println!("浮点数内存使用: {} 字节", float_num.memory_size());

    println!("\n=== 示例完成 ===");
}