Struct Rolling 

pub struct Rolling<'a> { /* private fields */ }

Rolling window aggregation over a Series.

Created by Series::rolling(). Provides methods for computing rolling statistics over a sliding window.

Implementations

impl Rolling<'_>

pub fn sum(&self) -> Result<Series, FrameError>

Rolling sum.

pub fn mean(&self) -> Result<Series, FrameError>

Rolling mean.

pub fn min(&self) -> Result<Series, FrameError>

Rolling minimum.

pub fn max(&self) -> Result<Series, FrameError>

Rolling maximum.

pub fn std(&self) -> Result<Series, FrameError>

Rolling sample standard deviation (ddof=1).

Examples found in repository

examples/bench_rolling_var.rs (line 72)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn count(&self) -> Result<Series, FrameError>

Rolling count of non-null values.

pandas count() is special: min_periods checks WINDOW SIZE, not non-null count. This differs from sum/mean/etc. where min_periods checks non-null count. If the window has at least min_periods elements, count returns the number of non-nulls (which can be 0).

pub fn var(&self) -> Result<Series, FrameError>

Rolling sample variance (ddof=1).

Examples found in repository

examples/bench_rolling_var.rs (line 71)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn median(&self) -> Result<Series, FrameError>

Rolling median.

pub fn first(&self) -> Result<Series, FrameError>

Rolling first non-null value.

pub fn last(&self) -> Result<Series, FrameError>

Rolling last non-null value.

pub fn prod(&self) -> Result<Series, FrameError>

Rolling product.

Examples found in repository

examples/bench_rolling_var.rs (line 76)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn quantile(&self, q: f64) -> Result<Series, FrameError>

Rolling quantile.

Matches series.rolling(window).quantile(q).

pub fn apply<F>(&self, func: F) -> Result<Series, FrameError>

where F: Fn(&[f64]) -> f64,

Apply a custom function over the rolling window.

Matches series.rolling(window).apply(func).

pub fn corr(&self, other: &Series) -> Result<Series, FrameError>

Rolling pairwise correlation with another Series.

Matches series.rolling(window).corr(other). Computes Pearson correlation over each rolling window.

pub fn cov(&self, other: &Series) -> Result<Series, FrameError>

Rolling pairwise covariance with another Series.

Matches series.rolling(window).cov(other). Computes sample covariance (ddof=1) over each rolling window.

pub fn skew(&self) -> Result<Series, FrameError>

Rolling skewness (bias=False, Fisher’s definition).

Matches pd.Series.rolling(window).skew().

Examples found in repository

examples/bench_rolling_var.rs (line 73)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn kurt(&self) -> Result<Series, FrameError>

Rolling excess kurtosis (Fisher’s definition, bias=False).

Matches pd.Series.rolling(window).kurt().

Examples found in repository

examples/bench_rolling_var.rs (line 74)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn kurtosis(&self) -> Result<Series, FrameError>

Alias for kurt() — pandas exposes both spellings on Series.rolling aggregations.

pub fn agg(&self, funcs: &[&str]) -> Result<DataFrame, FrameError>

Aggregate with multiple functions, returning a DataFrame.

Matches series.rolling(window).agg(['sum', 'mean']). Returns a DataFrame with one column per function, same index as the input.

pub fn aggregate(&self, funcs: &[&str]) -> Result<DataFrame, FrameError>

pandas alias for Self::agg.

Matches series.rolling(window).aggregate([...]).

pub fn sem(&self) -> Result<Series, FrameError>

Rolling standard error of the mean.

Matches series.rolling(window).sem().

Examples found in repository

examples/bench_rolling_var.rs (line 75)

fn run_api(s: &Series, window: usize, min_periods: Option<usize>, center: bool, a: Agg) -> Series {
    let r = if center {
        s.rolling_center(window, min_periods)
    } else {
        s.rolling(window, min_periods)
    };
    match a {
        Agg::Var => r.var(),
        Agg::Std => r.std(),
        Agg::Skew => r.skew(),
        Agg::Kurt => r.kurt(),
        Agg::Sem => r.sem(),
        Agg::Prod => r.prod(),
    }
    .unwrap()
}

pub fn rank( &self, method: &str, ascending: bool, na_option: &str, ) -> Result<Series, FrameError>

Rank the current observation within each rolling window.

Matches series.rolling(window).rank(). The emitted value is the rank of the row’s own value within its window.

pub fn exclusions(&self) -> Vec<String>

Frozenset-style label set excluded from this rolling window.

Series rolling windows have no excluded columns.

pub fn ndim(&self) -> usize

Number of dimensions of the underlying object. Series rolling is 1D.