tcal_rs 0.2.0

Number theory functions library - Rust port of libqalculate number theory module
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

use crate::fprice::PriceFormatter;

pub struct Formatter;

impl Formatter {
    pub fn full(value: f64) -> String {
        let int_value = value as i64;
        let dec = PriceFormatter::format(int_value);

        // Format the floating-point value, removing unnecessary trailing zeros
        let float_str = if value.fract() == 0.0 {
            format!("{}", value as i64)
        } else {
            // Remove trailing zeros but keep at least one decimal place
            let s = format!("{:.6}", value);
            s.trim_end_matches('0').trim_end_matches('.').to_string()
        };

        format!(
            "        {}\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━\nHEX : \"0x{:X}\"\nDEC : \"{}\"\nOCT : \"0o{:o}\"\nBIN : \"{}\"\n{}\n",
            float_str,
            int_value,
            dec,
            int_value,
            Self::bin(int_value),
            Self::format_64bit(int_value)
        )
    }

    fn bin(v: i64) -> String {
        let raw = format!("{:b}", v);
        let pad = (4 - raw.len() % 4) % 4;
        let s = format!("{}{}", "0".repeat(pad), raw);

        s.chars()
            .collect::<Vec<_>>()
            .chunks(4)
            .map(|c| c.iter().collect::<String>())
            .collect::<Vec<_>>()
            .join(" ")
    }

    fn format_64bit(value: i64) -> String {
        let bits = format!("{:064b}", value);

        let upper = &bits[0..32];
        let lower = &bits[32..64];

        format!(
            "{}\n63                      47                  32\n\n{}\n31                      15                   0",
            Self::group4(upper),
            Self::group4(lower)
        )
    }

    fn group4(s: &str) -> String {
        s.chars()
            .collect::<Vec<_>>()
            .chunks(4)
            .map(|c| c.iter().collect::<String>())
            .collect::<Vec<_>>()
            .join("  ")
    }
}