tcal_rs 0.1.1

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

pub struct ResultFormatter;

impl ResultFormatter {
    pub fn full_output(value: i64, formatted: &str) -> String {
        let hex = format!("0x{:X}", value);
        let oct = format!("0o{:o}", value);
        let bin = Self::format_bin(value);
        let binary_64 = Self::format_64bit(value);

        format!(
            "\t{}\n\
━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\
HEX : \"{}\"\n\
DEC : \"{}\"\n\
OCT : \"{}\"\n\
BIN : \"{}\"\n\
{}\n",
            formatted, hex, formatted, oct, bin, binary_64
        )
    }

    fn format_bin(value: i64) -> String {
        let raw = format!("{:b}", value);
        let padding = (4 - raw.len() % 4) % 4;
        let padded = format!("{}{}", "0".repeat(padding), raw);

        let grouped = padded
            .chars()
            .collect::<Vec<_>>()
            .chunks(4)
            .map(|c| c.iter().collect::<String>())
            .collect::<Vec<_>>()
            .join(" ");

        format!("0b{}", grouped)
    }

    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("  ")
    }
}