plr 0.3.2

Performs greedy or optimal error-bounded piecewise linear regression (PLR) and spline 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
145

// < begin copyright >
// Copyright Ryan Marcus 2019
//
// This file is part of plr.
//
// plr is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// plr is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with plr.  If not, see <http://www.gnu.org/licenses/>.
//
// < end copyright >
use crate::data::*;
use crate::util::*;
use std::collections::VecDeque;
use superslice::*;

pub fn sin_data() -> Vec<(f64, f64)> {
    let mut data = Vec::new();

    for i in 0..1000 {
        let x = (i as f64) / 1000.0 * 7.0;
        let y = f64::sin(x);
        data.push((x, y));
    }

    return data;
}

pub fn linear_data(slope: f64, intercept: f64) -> Vec<(f64, f64)> {
    let mut data = Vec::new();

    for i in 0..10 {
        let x = (i as f64) / 1000.0;
        let y = x * slope + intercept;
        data.push((x, y));
    }

    return data;
}

pub fn precision_data() -> Vec<(f64, f64)> {
    let mut data = Vec::new();

    for i in 0..1000 {
        let x = ((i as f64) / 1000.0) * f64::powi(2.0, 60);

        let y = i as f64;

        data.push((x, y));
    }

    return data;
}

pub fn osm_data() -> Vec<(f64, f64)> {
    return OSM_DATA
        .iter()
        .map(|&(x, y)| (x as f64, y as f64))
        .collect();
}

pub fn fb_data() -> Vec<(f64, f64)> {
    return FB_DATA.iter().map(|&(x, y)| (x as f64, y as f64)).collect();
}

pub fn verify_gamma(gamma: f64, data: &[(f64, f64)], segments: &[Segment]) {
    let mut seg_q = VecDeque::new();

    for segment in segments {
        seg_q.push_back(segment);
    }

    for &(x, y) in data {
        while seg_q.front().unwrap().stop <= x {
            seg_q.pop_front();
        }

        let seg = seg_q.front().unwrap();

        assert!(seg.start <= x);
        assert!(seg.stop >= x);

        let line = Line::new(seg.slope, seg.intercept);
        let pred = line.at(x).y;

        assert!(
            f64::abs(pred - y) <= gamma,
            "Prediction of {} was not within gamma ({}) of true value {}",
            pred,
            gamma,
            y
        );
    }
}

fn spline_interpolate(pt: f64, knots: &[(f64, f64)]) -> (f64, f64) {
    let upper_idx = usize::min(
        knots.len() - 1,
        knots.upper_bound_by(|x| x.0.partial_cmp(&pt).unwrap()),
    );
    let lower_idx = upper_idx - 1;

    return Point::from_tuple(knots[lower_idx])
        .line_to(&Point::from_tuple(knots[upper_idx]))
        .at(pt)
        .as_tuple();
}

pub fn verify_gamma_splines(gamma: f64, data: &[(f64, f64)], pts: &[(f64, f64)]) {
    println!("{:?}", pts);
    for &(x, y) in data {
        let pred = spline_interpolate(x, pts);
        assert!(
            f64::abs(pred.1 - y) <= gamma,
            "Prediction of {} was not within gamma ({}) of true value {}",
            pred.1,
            gamma,
            y
        );
    }
}

pub fn verify_gamma_splines_cast(gamma: f64, data: &[(f64, f64)], pts: &[(f64, f64)]) {
    println!("{:?}", pts);
    for &(x, y) in data {
        let x = (x as u64) as f64;
        let pred = spline_interpolate(x, pts);
        let pred = pred.1 as u64;
        assert!(
            f64::abs(pred as f64 - y) <= gamma,
            "Prediction of {} was not within gamma ({}) of true value {}",
            pred,
            gamma,
            y
        );
    }
}