relearn 0.3.1

A Reinforcement Learning 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

//! Formatting utilities
use std::fmt;
use std::time::Duration;

/// Pretty-printing
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PrettyPrint<T>(pub T);

impl fmt::Display for PrettyPrint<f64> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let magnitude = self.0.abs();
        if (magnitude >= 1e6 || magnitude <= 1e-4) && self.0 != 0.0 {
            fmt::LowerExp::fmt(&self.0, f)
        } else {
            fmt::Display::fmt(&self.0, f)
        }
    }
}

impl fmt::Display for PrettyPrint<Duration> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // The built-in debug output works
        fmt::Debug::fmt(&self.0, f)
    }
}

/// Display a frequency
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct Frequency(pub f64);

impl Frequency {
    #[must_use]
    pub fn from_period(period: Duration) -> Self {
        Self(period.as_secs_f64().recip())
    }
}

impl fmt::Display for Frequency {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let value = self.0;
        // Half-open ranges in match statements are not yet stable; have to use if instead.
        let (coef, unit) = if (1e3..1e6).contains(&value) {
            (value / 1e3, "kHz")
        } else if (1e6..1e9).contains(&value) {
            (value / 1e6, "MHz")
        } else if (1e9..1e12).contains(&value) {
            (value / 1e9, "GHz")
        } else {
            (value, "Hz")
        };
        fmt::Display::fmt(&PrettyPrint(coef), f)?;
        f.write_str(unit)
    }
}

/// Wraps a closure as the Display implementation
#[derive(Debug)]
pub struct DisplayFn<F>(pub F)
where
    // Bounded here so that the closure type does not have to be specified on creation
    F: Fn(&mut fmt::Formatter) -> fmt::Result;

impl<F> fmt::Display for DisplayFn<F>
where
    F: Fn(&mut fmt::Formatter) -> fmt::Result,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        (self.0)(f)
    }
}