pav_regression 0.7.0

The pair adjacent violators algorithm for isotonic regression
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
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::coordinate::Coordinate;
use serde::Serialize;

/// A point in 2D cartesian space
#[derive(Debug, PartialEq, Copy, Clone, Serialize)]
pub struct Point<T: Coordinate> {
    pub(crate) x: T,
    pub(crate) y: T,
    pub(crate) weight: f64,
}

impl<T: Coordinate> Default for Point<T> {
    fn default() -> Self {
        Point {
            x: T::zero(),
            y: T::zero(),
            weight: 1.0,
        }
    }
}

impl<T: Coordinate> Point<T> {
    /// Create a new Point.
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let point = Point::new(1.0, 2.0);
    /// assert_eq!(*point.x(), 1.0);
    /// assert_eq!(*point.y(), 2.0);
    /// assert_eq!(point.weight(), 1.0);
    /// ```
    pub fn new(x: T, y: T) -> Point<T> {
        Point { x, y, weight: 1.0 }
    }

    /// Create a new Point with a specified weight.
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let point = Point::new_with_weight(1.0, 2.0, 0.5);
    /// assert_eq!(*point.x(), 1.0);
    /// assert_eq!(*point.y(), 2.0);
    /// assert_eq!(point.weight(), 0.5);
    /// ```
    pub fn new_with_weight(x: T, y: T, weight: f64) -> Point<T> {
        Point { x, y, weight }
    }

    /// The x position of the point.
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let point = Point::new(1.0, 2.0);
    /// assert_eq!(*point.x(), 1.0);
    /// ```
    pub fn x(&self) -> &T {
        &self.x
    }

    /// The y position of the point.
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let point = Point::new(1.0, 2.0);
    /// assert_eq!(*point.y(), 2.0);
    /// ```
    pub fn y(&self) -> &T {
        &self.y
    }

    /// The weight of the point (initially 1.0).
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let point = Point::new(1.0, 2.0);
    /// assert_eq!(point.weight(), 1.0);
    /// ```
    pub fn weight(&self) -> f64 {
        self.weight
    }

    /// Merges this point with another point, updating the coordinates and weight.
    ///
    /// # Examples
    ///
    /// ```
    /// use pav_regression::Point;
    ///
    /// let mut point1 = Point::new_with_weight(1.0, 2.0, 0.5);
    /// let point2 = Point::new_with_weight(3.0, 4.0, 1.5);
    /// point1.merge_with(&point2);
    /// assert_eq!(*point1.x(), 2.5);
    /// assert_eq!(*point1.y(), 3.5);
    /// assert_eq!(point1.weight(), 2.0);
    /// ```
    pub fn merge_with(&mut self, other: &Point<T>) {
        let total_weight = self.weight + other.weight;
        self.x = (self.x * T::from_float(self.weight) + other.x * T::from_float(other.weight))
            / T::from_float(total_weight);
        self.y = (self.y * T::from_float(self.weight) + other.y * T::from_float(other.weight))
            / T::from_float(total_weight);
        self.weight = total_weight;
    }
}

impl<T: Coordinate> From<(T, T)> for Point<T> {
    fn from(tuple: (T, T)) -> Self {
        Point::new(tuple.0, tuple.1)
    }
}

#[allow(dead_code)]
/// Interpolates the y value at a given x position between two points.
///
/// # Examples
///
/// ```
/// use pav_regression::Point;
/// use pav_regression::point::interpolate_two_points;
///
/// let point1 = Point::new(0.0, 0.0);
/// let point2 = Point::new(2.0, 2.0);
/// let interpolated_y = interpolate_two_points(&point1, &point2, 1.0);
/// assert_eq!(interpolated_y, 1.0);
/// ```
pub fn interpolate_two_points<T: Coordinate>(a: &Point<T>, b: &Point<T>, at_x: T) -> T {
    let prop = (at_x - a.x) / (b.x - a.x);
    a.y + (b.y - a.y) * prop
}