Struct plr::OptimalPLR

pub struct OptimalPLR { /* fields omitted */ }

Performs an optimal piecewise linear regression (PLR) in an online fashion. This approach uses linear time for each call to process and potentially linear space. In practice, the space used is generally a small fraction of the data. If constant space is required for your applications, please see GreedyPLR.

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::OptimalPLR;
// 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 = OptimalPLR::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.

Methods

impl OptimalPLR

pub fn new(gamma: f64) -> OptimalPLR

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

Examples

To perform an optimal PLR with a maximum error of 0.05:

use plr::OptimalPLR;
let plr = OptimalPLR::new(0.05);

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

Processes a single point using the optimal 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.