equation 1.0.0

A Rust library for mathematical expression evaluation and simplification
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
124
125
126

/// Represents a collection of trigonometric and hyperbolic functions.
///
/// This enumeration lists a set of supported mathematical functions. Each variant corresponds
/// to a specific function and can be executed with a given argument to produce a result.
#[derive(Debug)]
pub enum Functions {
    Sin,
    Cos,
    Tan,
    Asin,
    Acos,
    Atan,
    Sinh,
    Cosh,
    Tanh,
    Asinh,
    Acosh,
    Atanh,
}

impl Functions {
    /// Evaluates the trigonometric or hyperbolic function with the given argument.
    ///
    /// This method applies the function represented by the enum variant to the provided argument.
    ///
    /// # Arguments
    ///
    /// * `arg` - A floating-point value representing the input to the function.
    ///
    /// # Returns
    ///
    /// Returns the result of the function evaluation as a floating-point value.
    pub fn run(&self, arg: f64) -> f64 {
        match self {
            Self::Sin => arg.sin(),
            Self::Cos => arg.cos(),
            Self::Tan => arg.tan(),
            Self::Asin => arg.asin(),
            Self::Acos => arg.acos(),
            Self::Atan => arg.atan(),
            Self::Sinh => arg.sinh(),
            Self::Cosh => arg.cosh(),
            Self::Tanh => arg.tanh(),
            Self::Asinh => arg.asinh(),
            Self::Acosh => arg.acosh(),
            Self::Atanh => arg.atanh(),
        }
    }
}

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

    #[test]
    fn it_works_with_sin() {
        let func = Functions::Sin;
        assert_eq!(func.run(10.0), -0.5440211108893698);
    }

    #[test]
    fn it_works_with_cos() {
        let func = Functions::Cos;
        assert_eq!(func.run(10.0), -0.8390715290764524);
    }

    #[test]
    fn it_works_with_tan() {
        let func = Functions::Tan;
        assert_eq!(func.run(10.0), 0.6483608274590867);
    }

    #[test]
    fn it_works_with_asin() {
        let func = Functions::Asin;
        assert_eq!(func.run(0.5), 0.5235987755982988);
    }

    #[test]
    fn it_works_with_acos() {
        let func = Functions::Acos;
        assert_eq!(func.run(0.5), 1.0471975511965976);
    }

    #[test]
    fn it_works_with_atan() {
        let func = Functions::Atan;
        assert_eq!(func.run(10.0), 1.4711276743037345);
    }

    #[test]
    fn it_works_with_sinh() {
        let func = Functions::Sinh;
        assert_eq!(func.run(10.0), 11013.232874703393);
    }

    #[test]
    fn it_works_with_cosh() {
        let func = Functions::Cosh;
        assert_eq!(func.run(10.0), 11013.232920103323);
    }

    #[test]
    fn it_works_with_tanh() {
        let func = Functions::Tanh;
        assert_eq!(func.run(10.0), 0.9999999958776927);
    }

    #[test]
    fn it_works_with_asinh() {
        let func = Functions::Asinh;
        assert_eq!(func.run(10.0), 2.99822295029797);
    }

    #[test]
    fn it_works_with_acosh() {
        let func = Functions::Acosh;
        assert_eq!(func.run(10.0), 2.993222846126381);
    }

    #[test]
    fn it_works_with_atanh() {
        let func = Functions::Atanh;
        assert_eq!(func.run(0.5), 0.5493061443340549);
    }
}