hipparchus-az 0.1.2

Utility for angle representation, conversion and calculations
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

use std::fmt::Display;
use std::str::FromStr;
use num::Signed;
use num_enum::{IntoPrimitive, TryFromPrimitive};

/// Sign of a number
#[repr(i8)]
#[derive(Debug, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
pub enum Sign
{
    /// Positive sign
    Positive = 1,

    /// Negative sign
    Negative = -1,
}

impl Sign
{
    /// Get the sign abbreviation
    pub fn abbr(self) -> &'static str
    {
        match self
        {
            Self::Positive => "+",
            Self::Negative => "-",
        }
    }
}

/// Trait for types that have a sign
pub trait WithSign
{
    /// Get the sign of the value
    fn sign(&self) -> Sign;
}

/// Implement `WithSign` trait for `Signed` types
impl<T:Signed> WithSign for T
{
    fn sign(&self) -> Sign
    {
        if self.is_negative() { Sign::Negative } else { Sign::Positive }
    }
}

/// Display `Sign` enum as a single character.
impl Display for Sign
{
    /// Display `Sign` enum as a single character.
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
    {
        write!(f, "{}", self.abbr())
    }
}

/// Parse `Sign` enum from a single character.
impl FromStr for Sign
{
    /// Error type
    type Err = ();

    /// Parse `Sign` enum from a single character.
    fn from_str(s: &str) -> Result<Self, Self::Err>
    {
        match s
        {
            "+" => Ok(Sign::Positive),
            "-" => Ok(Sign::Negative),
            _ => Err(()),
        }
    }
}

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

    #[rstest]
    #[case(1.0f32, Sign::Positive)]
    #[case(-1.0f32, Sign::Negative)]
    #[case(0.0f32, Sign::Positive)]
    fn test_sign_pos(#[case] v: f32, #[case] e: Sign)
    {
        assert_eq!(e, v.sign());
    }

    #[rstest]
    #[case(Sign::Positive, "+")]
    #[case(Sign::Negative, "-")]
    fn test_sign_str(#[case] s: Sign, #[case] text: String)
    {
        assert_eq!(text, s.to_string());
        assert_eq!(s, Sign::from_str(text.as_str()).unwrap());
    }

    #[rstest]
    #[case("")]
    #[case("ABCD")]
    fn test_sign_str_error(#[case] text: String)
    {
        let unit = Sign::from_str(text.as_str());
        assert!(unit.is_err());
    }
}