talrost 0.1.2

A mathematics library for embedded scientific computation.
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

use std::num::FpCategory;

/// Returns a specified-width string representation of the provided f64.
/// The absolute minimum width is 3, but this may panic with overflow for widths
/// under 7.
#[allow(dead_code)]
pub fn format_f64(n: f64, width: usize) -> String {
    assert!(width >= 3);
    let mut output = String::new();
    let width_used: usize;

    let class = n.classify();

    if let FpCategory::Normal | FpCategory::Subnormal = class {
        // TODO: Better handling of subnormal case

        let mut formatting_width = 2;

        let n_abs = n.abs();

        if n_abs > n {
            output.push('-');
            formatting_width += 1;
        }

        let has_exponent: bool;
        let exp_signed: isize = n_abs.abs().log10() as isize;
        if exp_signed == 0 {
            has_exponent = false;
        } else {
            has_exponent = true;
            formatting_width += 1;
            if exp_signed < 0 {
                formatting_width += 1; // Exponent is negative, we'll need a '-'
            }
            let exp_wdh = 1 + (exp_signed as f64).abs().log10() as usize;
            formatting_width += exp_wdh; // TODO: use int_log when stable
        }

        // TODO: Check trailing zeros and compact when possible
        if !has_exponent {
            output.push_str(&format!("{:.w$}", n_abs, w = width - formatting_width));
        } else {
            assert!(formatting_width <= width);
            output.push_str(&format!("{:1.w$e}", n_abs, w = width - formatting_width));
        }
        width_used = width;
    } else if let FpCategory::Zero = class {
        // No distinction is made for negative zero
        output.push_str("0.");
        width_used = 2;
    } else if let FpCategory::Infinite = class {
        if n == f64::INFINITY {
            output.push('∞');
            width_used = 1;
        } else {
            output.push_str("-∞");
            width_used = 2;
        }
    } else {
        output.push_str("NaN");
        width_used = 3;
    }

    let padding = width - width_used;
    for _ in 0..padding {
        output.push(' ');
    }
    output
}