frequenz-microgrid 0.2.2

A high-level interface to the Frequenz Microgrid API.
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

// License: MIT
// Copyright © 2025 Frequenz Energy-as-a-Service GmbH

//! This module defines the `Frequency` quantity and its operations.

qty_ctor! {
    #[doc = "A physical quantity representing frequency."]
    Frequency => {
        (from_hertz, as_hertz, "Hz", 1.0),
        (from_kilohertz, as_kilohertz, "kHz", 1e3),
        (from_megahertz, as_megahertz, "MHz", 1e6),
        (from_gigahertz, as_gigahertz, "GHz", 1e9),
    }
}

#[cfg(test)]
mod tests {
    use super::Frequency;
    use crate::quantity::{Percentage, Quantity as _, test_utils::assert_f32_eq};

    #[test]
    fn test_frequency() {
        let freq_1 = Frequency::from_hertz(1000.0);

        assert_f32_eq(freq_1.as_hertz(), 1000.0);
        assert_f32_eq(freq_1.as_kilohertz(), 1.0);
        assert_f32_eq(freq_1.as_megahertz(), 0.001);
        assert_f32_eq(freq_1.as_gigahertz(), 0.000_001);

        let freq_2 = Frequency::from_kilohertz(1.2);
        assert_f32_eq(freq_2.as_hertz(), 1200.0);

        let freq_2 = Frequency::from_megahertz(0.0012);
        assert_f32_eq(freq_2.as_hertz(), 1200.0);

        let freq_2 = Frequency::from_gigahertz(0.000_0012);
        assert_f32_eq(freq_2.as_hertz(), 1200.0);

        assert!(freq_1 < freq_2);
        assert!(freq_2 > freq_1);

        assert_f32_eq((freq_1 + freq_2).as_hertz(), 2200.0);
        assert_f32_eq((freq_2 - freq_1).as_hertz(), 200.0);
        assert_f32_eq((freq_1 * 2.0).as_hertz(), 2000.0);
        assert_f32_eq((freq_2 / 2.0).as_hertz(), 600.0);
        assert_f32_eq(
            (freq_2 * Percentage::from_percentage(50.0)).as_hertz(),
            600.0,
        );
        assert_f32_eq(freq_2 / freq_1, 1.2);

        assert_f32_eq(Frequency::zero().as_hertz(), 0.0);
    }

    #[test]
    fn test_frequency_formatting() {
        let s = |value| Frequency::from_hertz(value).to_string();
        let p = |value, prec| format!("{:.prec$}", Frequency::from_hertz(value), prec = prec);
        assert_eq!(s(0.0), "0 Hz");

        assert_eq!(s(1.558), "1.558 Hz");
        assert_eq!(p(1.558, 1), "1.6 Hz");

        assert_eq!(s(1.5508), "1.551 Hz");
        assert_eq!(p(1.5508, 5), "1.5508 Hz");

        assert_eq!(s(2030.0), "2.03 kHz");

        assert_eq!(s(2_030_022.0), "2.03 MHz");
        assert_eq!(s(2_030_022_123.0), "2.03 GHz");
        assert_eq!(p(2_030_022_123.0, 6), "2.030022 GHz");

        assert_eq!(s(-1.558), "-1.558 Hz");
        assert_eq!(p(-1.558, 1), "-1.6 Hz");

        assert_eq!(s(-2030.0), "-2.03 kHz");
        assert_eq!(p(-2030.0, 1), "-2 kHz");

        assert_eq!(s(-2_030_022.0), "-2.03 MHz");
        assert_eq!(s(-2_030_022_123.0), "-2.03 GHz");
        assert_eq!(p(-2_030_022_123.0, 6), "-2.030022 GHz");
    }
}