Struct livesplit_core::analysis::SkillCurve

pub struct SkillCurve { /* private fields */ }

The skill curve analyzes the SegmentHistory segment history across all segments. For each Segment, the segment times are sorted by length and weighted by their recency.

Plotting this on a graph with the y-axis representing the segment time and the x-axis representing the percentile, with the shortest time at 0 and the longest time at 1, yields the so called “skill curve”. If you sum all the different curves together for all the segments, you get the overall curve for the whole run.

Properties of the Skill Curve

If you sample the curve at 0, you get the simple sum of best segments, and if you sample the curve at 1, you get the simple sum of worst segments. At 0.5, you get the median segments. If you sample the individual segments at the same percentile where you find the Personal Best on the overall run’s curve, you get the Balanced PB. The position of the Balanced PB on the x-axis is the PB chance.

Implementations

impl SkillCurve

pub fn new() -> Self

Constructs a new empty skill curve. Before querying information, you need to calculate the curve for some segments.

pub fn len(&self) -> usize

Returns the number of segments this skill curve is comprised of.

pub fn is_empty(&self) -> bool

Returns true if there are no segments in this skill curve.

pub fn truncate(&mut self, len: usize)

Reduces the number of segments that are being considered by this curve.

pub fn for_segments(&mut self, segments: &[Segment], method: TimingMethod)

Calculate the skill curve for the segments and timing method provided. All previous information available in the skill curve will be discarded. The segment curve may not always contain information for all segments. Once a segment with no segment history is encountered, the remainder of the segments get discarded.

pub fn iter_segment_times_at_percentile(
    &self,
    percentile: f64
) -> impl Iterator<Item = TimeSpan> + '_

This function returns an iterator that iterates over each segment and yields their segment times for the percentile specified. A percentile of 0 yields the fastest times, while a percentile of 1 yields the slowest times.

pub fn iter_split_times_at_percentile(
    &self,
    percentile: f64,
    offset: TimeSpan
) -> impl Iterator<Item = TimeSpan> + '_

This function returns an iterator that iterates over each segment and yields their split times for the percentile specified. A percentile of 0 yields the fastest times, while a percentile of 1 yields the slowest times. The offset provided is the initial split time going into the first segment. This is only relevant when the segments don’t represent the beginning of the run.

pub fn find_percentile_for_time(
    &self,
    offset: TimeSpan,
    time_to_find: TimeSpan
) -> f64

Searches the curve for the final run time specified and returns the percentile the time can be found at. The percentile is always within the range 0..1. If the time specified cannot be found, the percentile saturates at one of those boundaries.

Trait Implementations

impl Clone for SkillCurve

fn clone(&self) -> SkillCurve

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for SkillCurve

fn default() -> SkillCurve

Returns the “default value” for a type.