parabola 0.1.1

Representation of a parabola of the form `ax² + bx + c`.
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

//! Representation of a straight line of the form `ax + b`.

use crate::Point;

/// Representation of a straight line of the form `ax + b`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Line {
    /// The line's slope.
    pub slope: f64,
    /// The y-coordinate of the line's intercept with the y-axis
    pub intercept: f64,
}

impl Line {
    /// Creates a new line from its slope and its y-axis intercept.
    ///
    /// # Example
    /// ```
    /// # use parabola::*;
    /// // y = 2x + 5
    /// let line = Line::from_slope_intercept(2.0, 5.0);
    /// ```
    #[inline]
    #[must_use]
    pub fn from_slope_intercept(slope: f64, intercept: f64) -> Self {
        Self { slope, intercept }
    }

    /// Creates a new line from its slope and its y-axis intercept.
    ///
    /// # Example
    /// ```
    /// # use parabola::*;
    /// // y = 2x + 5
    /// let slope = 5.0;
    /// let point = Point{ x: 1.0, y: 7.0 };
    /// let line = Line::from_slope_point(2.0, point);
    /// ```
    #[inline]
    #[must_use]
    pub fn from_slope_point(slope: f64, point: Point) -> Self {
        Self {
            slope,
            intercept: point.y - slope * point.x,
        }
    }

    /// Creates a new line from 2 points.
    ///
    /// # Example
    /// ```
    /// # use parabola::*;
    /// // y = 2x + 5
    /// let point1 = Point{ x: 0.0, y: 5.0 };
    /// let point2 = Point{ x: 1.0, y: 7.0 };
    /// let line = Line::from_points(point1, point2);
    /// ```
    #[inline]
    #[must_use]
    pub fn from_points(point1: Point, point2: Point) -> Self {
        let slope = (point2.y - point1.y) / (point2.x - point1.x);
        Self {
            slope,
            intercept: point1.y - slope * point1.x,
        }
    }
}

impl Line {
    /// Evaluates the parabola at a specific `x`.
    ///
    /// # Example
    /// ```
    /// # use parabola::*;
    /// // y = 2x + 5
    /// let line = Line::from_slope_intercept(2.0, 5.0);
    /// approx::assert_relative_eq!(line.eval(-1.0), 3.0);
    /// ```
    #[inline]
    #[must_use]
    pub fn eval(&self, x: f64) -> f64 {
        self.slope * x + self.intercept
    }
}

#[cfg(test)]
mod test_line {
    use super::*;
    use approx::assert_relative_eq;

    const EPS: f64 = 1e-30;

    #[test]
    fn from_slope_intercept() {
        // y = 2x + 1
        let line = Line::from_slope_intercept(2.0, 1.0);
        assert_eq!(line.slope, 2.0);
        assert_eq!(line.intercept, 1.0);
        assert_relative_eq!(line.eval(0.5), 2.0, epsilon = EPS);
    }

    #[test]
    fn from_slope_point() {
        // y = 2x + 1
        let point = Point { x: 1.0, y: 3.0 };
        let line = Line::from_slope_point(2.0, point);
        assert_eq!(line.slope, 2.0);
        assert_eq!(line.intercept, 1.0);
        assert_relative_eq!(line.eval(0.5), 2.0, epsilon = EPS);
    }

    #[test]
    fn from_points() {
        // y = 2x + 1
        let point1 = Point { x: 0.0, y: 1.0 };
        let point2 = Point { x: 1.0, y: 3.0 };
        let line = Line::from_points(point1, point2);
        assert_eq!(line.slope, 2.0);
        assert_eq!(line.intercept, 1.0);
        assert_relative_eq!(line.eval(0.5), 2.0, epsilon = EPS);
    }
}