friendly 0.2.0

Human-friendly display library
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use super::{Prefix, PrefixFamily, Scale};

/// A decimal scale.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Decimal {
    pfx: &'static str,
    exp: i32,
}

impl Decimal {
    /// Create a new decimal prefix.
    const fn new(pfx: &'static str, exp: i32) -> Decimal {
        Decimal { pfx, exp }
    }

    pub const YOCTO: Decimal = Decimal::new("y", -24);
    pub const ZEPTO: Decimal = Decimal::new("z", -21);
    pub const ATTO: Decimal = Decimal::new("a", -18);
    pub const FEMTO: Decimal = Decimal::new("f", -15);
    pub const PICO: Decimal = Decimal::new("p", -12);
    pub const NANO: Decimal = Decimal::new("n", -9);
    pub const MICRO: Decimal = Decimal::new("μ", -6);
    pub const MILLI: Decimal = Decimal::new("m", -3);
    pub const UNIT: Decimal = Decimal::new("", 0);
    pub const KILO: Decimal = Decimal::new("k", 3);
    pub const MEGA: Decimal = Decimal::new("M", 6);
    pub const GIGA: Decimal = Decimal::new("G", 9);
    pub const TERA: Decimal = Decimal::new("T", 12);
    pub const PETA: Decimal = Decimal::new("P", 15);
    pub const EXA: Decimal = Decimal::new("E", 18);
    pub const ZETTA: Decimal = Decimal::new("Z", 21);
    pub const YOTTA: Decimal = Decimal::new("Y", 24);

    pub const AUTO: Scale<Decimal> = Scale::Auto;

    pub const ALL_PREFIXES: &'static [&'static Decimal] = &[
        &Decimal::YOCTO,
        &Decimal::ZEPTO,
        &Decimal::ATTO,
        &Decimal::FEMTO,
        &Decimal::PICO,
        &Decimal::NANO,
        &Decimal::MICRO,
        &Decimal::MILLI,
        &Decimal::UNIT,
        &Decimal::KILO,
        &Decimal::MEGA,
        &Decimal::GIGA,
        &Decimal::TERA,
        &Decimal::PETA,
        &Decimal::EXA,
        &Decimal::ZETTA,
        &Decimal::YOTTA,
    ];
}

impl Prefix for Decimal {
    #[inline]
    fn base(&self) -> i32 {
        10
    }

    #[inline]
    fn exponent(&self) -> i32 {
        self.exp
    }

    fn label(&self) -> &'static str {
        self.pfx
    }
}

impl PrefixFamily for Decimal {
    type Prefix = Decimal;

    fn unit_prefix() -> Decimal {
        Decimal::UNIT
    }

    fn all_prefixes() -> &'static [&'static Decimal] {
        Decimal::ALL_PREFIXES
    }
}

#[test]
fn test_multipliers() {
    assert_eq!(Decimal::UNIT.multiplier(), 1.0);
    assert_eq!(Decimal::KILO.multiplier(), 1000.0);
    assert_eq!(Decimal::MEGA.multiplier(), 1_000_000.0);
    assert_eq!(Decimal::GIGA.multiplier(), 1_000_000_000.0);
}

#[test]
fn test_unit_adjust() {
    assert_eq!(Decimal::UNIT.scale_value(1250), 1250.0);
}

#[test]
fn test_kilo_adjust() {
    assert_eq!(Decimal::KILO.scale_value(1250), 1.250);
}