hoomd-utility 1.1.0

Types and methods commonly used in hoomd-rs.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// Copyright (c) 2024-2026 The Regents of the University of Michigan.
// Part of hoomd-rs, released under the BSD 3-Clause License.

//! Implement `OpenUnitIntervalNumber`

use serde::{Deserialize, Serialize};
use std::fmt;

use super::Error;

/// A f64 value in the interval (0,1)
///
/// # Example
///
/// ```
/// use hoomd_utility::valid::OpenUnitIntervalNumber;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let v = OpenUnitIntervalNumber::try_from(0.5)?;
/// # Ok(())
/// # }
/// ```
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct OpenUnitIntervalNumber(f64);

impl OpenUnitIntervalNumber {
    /// Access the value.
    ///
    /// # Example
    ///
    /// ```
    /// use hoomd_utility::valid::OpenUnitIntervalNumber;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let v = OpenUnitIntervalNumber::try_from(0.5)?;
    ///
    /// assert_eq!(v.get(), 0.5);
    /// # Ok(())
    /// # }
    #[must_use]
    #[inline]
    pub fn get(&self) -> f64 {
        self.0
    }
}

impl TryFrom<f64> for OpenUnitIntervalNumber {
    type Error = Error;

    /// Convert [`f64`] to [`OpenUnitIntervalNumber`].
    ///
    /// # Example
    ///
    /// Valid conversion:
    /// ```
    /// use hoomd_utility::valid::OpenUnitIntervalNumber;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let v = OpenUnitIntervalNumber::try_from(0.5)?;
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// Invalid conversion
    /// ```
    /// use hoomd_utility::valid::OpenUnitIntervalNumber;
    ///
    /// let result = OpenUnitIntervalNumber::try_from(2.0);
    /// assert!(matches!(
    ///     result,
    ///     Err(hoomd_utility::valid::Error::NotInOpenUnitInterval(_))
    /// ));
    /// ```
    ///
    /// # Errors
    ///
    /// [`Error::NotFinite`] when `v` is not finite.
    /// [`Error::NotInOpenUnitInterval`] when `v` is not in (0,1).
    #[inline]
    fn try_from(v: f64) -> Result<OpenUnitIntervalNumber, Error> {
        if !v.is_finite() {
            Err(Error::NotFinite(v))
        } else if v <= 0.0 || v >= 1.0 {
            Err(Error::NotInOpenUnitInterval(v))
        } else {
            Ok(OpenUnitIntervalNumber(v))
        }
    }
}

impl fmt::Display for OpenUnitIntervalNumber {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use assert2::check;

    #[test]
    fn open_unit_validation() {
        let result = OpenUnitIntervalNumber::try_from(f64::INFINITY);
        check!(result == Err(Error::NotFinite(f64::INFINITY)));

        let result = OpenUnitIntervalNumber::try_from(-f64::INFINITY);
        check!(result == Err(Error::NotFinite(-f64::INFINITY)));

        let result = OpenUnitIntervalNumber::try_from(f64::NAN);
        check!(matches!(result, Err(Error::NotFinite(_))));

        let result = OpenUnitIntervalNumber::try_from(0.0);
        check!(matches!(result, Err(Error::NotInOpenUnitInterval(_))));

        let result = OpenUnitIntervalNumber::try_from(-1.0);
        check!(matches!(result, Err(Error::NotInOpenUnitInterval(_))));

        let result = OpenUnitIntervalNumber::try_from(1.0_f64.next_down());
        check!(result == Ok(OpenUnitIntervalNumber(1.0_f64.next_down())));
    }
}