Struct plr::regression::GreedyPLR

pub struct GreedyPLR { /* private fields */ }

Performs a greedy piecewise linear regression (PLR) in an online fashion. This approach uses constant time for each call to process as well as constant space. Note that, due to the greedy nature of the algorithm, more regression segments may be created than strictly needed. For PLR with a minimal number of segments, please see OptimalPLR.

Each call to process consumes a single point. Each time it is called, process returns either a Segment representing a piece of the final regression, or None. If your stream of points terminates, you can call finish to flush the buffer and return the final segment.

Example

use plr::regression::GreedyPLR;
// first, generate some data points...
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));
}
  
let mut plr = GreedyPLR::new(0.0005); // gamma = 0.0005, the maximum regression error
  
let mut segments = Vec::new();
  
for (x, y) in data {
    // when `process` returns a segment, we should add it to our list
    if let Some(segment) = plr.process(x, y) {
        segments.push(segment);
    }
}

// because we have a finite amount of data, we flush the buffer and get the potential
// last segment.
if let Some(segment) = plr.finish() {
    segments.push(segment);
}

// the `segments` vector now contains all segments for this regression.

Implementations

impl GreedyPLR

pub fn new(gamma: f64) -> GreedyPLR

Enables performing PLR using a greedy algorithm with a fixed gamma (maximum error).

Examples

To perform a greedy PLR with a maximum error of 0.05:

use plr::regression::GreedyPLR;
let plr = GreedyPLR::new(0.05);

pub fn process(&mut self, x: f64, y: f64) -> Option<Segment>

Processes a single point using the greedy PLR algorithm. This function returns a new Segment when the current segment cannot accommodate the passed point, and returns None if the current segment could be (greedily) adjusted to fit the point.

pub fn finish(self) -> Option<Segment>

Terminates the PLR process, returning a final segment if required.