assessment 1.0.0

A library that allows different types of assessments, to convert between them and to perform basic operations.
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
127
128
129
130
131

use crate::utilities;
use impl_ops::*;
use std::ops;

/// Linear function struct.
///
/// f(x) = ax + b; a == slope & b == intercept.
#[derive(Debug, PartialEq, Clone)]
pub struct LinearFunction {
    /// Slope.
    slope: f64,

    /// Intercept.
    intercept: f64,
}

impl LinearFunction {
    /// Linear function constructor.
    ///
    /// # Arguments
    /// * `slope`: Function slope.
    /// * `intercept`: Function intercept.
    ///
    /// # Examples
    ///
    /// ```
    /// # use assessment::fuzzy::membership::piecewise::LinearFunction;
    /// LinearFunction::new(2.3, 3.4);
    /// ```
    pub fn new(slope: f64, intercept: f64) -> Self {
        Self {
            slope: utilities::math::round_f64(slope, 5),
            intercept: utilities::math::round_f64(intercept, 5),
        }
    }

    /// Returns slope.
    ///
    /// ```
    /// # use assessment::fuzzy::membership::piecewise::LinearFunction;
    /// let function = LinearFunction::new(2.3, 3.4);
    /// assert_eq!(function.slope(), 2.3);
    /// ```
    pub fn slope(&self) -> f64 {
        self.slope
    }

    /// Returns intercept.
    ///
    /// ```
    /// # use assessment::fuzzy::membership::piecewise::LinearFunction;
    /// let function = LinearFunction::new(2.3, 3.4);
    /// assert_eq!(function.intercept(), 3.4);
    /// ```
    pub fn intercept(&self) -> f64 {
        self.intercept
    }

    /// Sums the current function with `other` function and returns a new function.
    ///
    /// # Arguments
    /// * `other`: Function to sum to the current one.
    ///
    /// # Examples
    ///
    /// ```
    /// # use assessment::fuzzy::membership::piecewise::LinearFunction;
    /// let a = LinearFunction::new(2.1, 3.1);
    /// let b = LinearFunction::new(2.3, 3.7);
    ///
    /// let sum_a_a = a.sum(&b);
    /// let sum_a_b = b.sum(&a);
    /// assert_eq!(sum_a_a.slope(), sum_a_b.slope());
    /// assert_eq!(sum_a_a.intercept(), sum_a_b.intercept());
    /// assert_eq!(sum_a_a.slope(), 4.4);
    /// assert_eq!(sum_a_a.intercept(), 6.8);
    /// ```
    pub fn sum(&self, other: &LinearFunction) -> Self {
        LinearFunction::new(self.slope + other.slope, self.intercept + other.intercept)
    }
}

impl_op!(+ |a: &LinearFunction, b: &LinearFunction| -> LinearFunction { a.sum(b) });
impl_op!(+ |a: LinearFunction, b: &LinearFunction| -> LinearFunction { a.sum(b) });
impl_op!(+ |a: &LinearFunction, b: LinearFunction| -> LinearFunction { a.sum(&b) });
impl_op!(+ |a: LinearFunction, b: LinearFunction| -> LinearFunction { a.sum(&b) });

#[cfg(test)]
mod tests {
    use crate::fuzzy::membership::piecewise::LinearFunction;

    #[test]
    fn sum_references() {
        let a = LinearFunction::new(2.1, 3.1);
        let b = LinearFunction::new(2.3, 3.7);

        let sum = &a + &b;
        assert_eq!(sum.slope(), 4.4);
        assert_eq!(sum.intercept(), 6.8);
    }

    #[test]
    fn sum_ownerships() {
        let a = LinearFunction::new(2.1, 3.1);
        let b = LinearFunction::new(2.3, 3.7);

        let sum = a + b;
        assert_eq!(sum.slope(), 4.4);
        assert_eq!(sum.intercept(), 6.8);
    }

    #[test]
    fn sum_ownership_reference() {
        let a = LinearFunction::new(2.1, 3.1);
        let b = LinearFunction::new(2.3, 3.7);

        let sum = a + &b;
        assert_eq!(sum.slope(), 4.4);
        assert_eq!(sum.intercept(), 6.8);
    }

    #[test]
    fn sum_reference_ownership() {
        let a = LinearFunction::new(2.1, 3.1);
        let b = LinearFunction::new(2.3, 3.7);

        let sum = &a + b;
        assert_eq!(sum.slope(), 4.4);
        assert_eq!(sum.intercept(), 6.8);
    }
}