Struct Data

pub struct Data<D>(/* private fields */);

Implementations

impl<D: AsMut<[f64]> + AsRef<[f64]>> Data<D>

pub fn new(data: D) -> Self

pub fn swap(&mut self, i: usize, j: usize)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, f64>

Trait Implementations

impl<D: Clone> Clone for Data<D>

fn clone(&self) -> Data<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Debug> Debug for Data<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: AsRef<[f64]>> Distribution<f64> for Data<D>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<D: AsMut<[f64]> + AsRef<[f64]>> Distribution<f64> for Data<D>

fn mean(&self) -> Option<f64>

Evaluates the sample mean, an estimate of the population mean.

Remarks

Returns f64::NAN if data is empty or an entry is f64::NAN

Examples

#[macro_use]
extern crate statrs;

use statrs::statistics::Distribution;
use statrs::statistics::Data;

let x = [];
let x = Data::new(x);
assert!(x.mean().unwrap().is_nan());

let y = [0.0, f64::NAN, 3.0, -2.0];
let y = Data::new(y);
assert!(y.mean().unwrap().is_nan());

let z = [0.0, 3.0, -2.0];
let z = Data::new(z);
assert_almost_eq!(z.mean().unwrap(), 1.0 / 3.0, 1e-15);

fn variance(&self) -> Option<f64>

Estimates the unbiased population variance from the provided samples

Remarks

On a dataset of size N, N-1 is used as a normalizer (Bessel’s correction).

Returns f64::NAN if data has less than two entries or if any entry is f64::NAN

Examples

use statrs::statistics::Distribution;
use statrs::statistics::Data;

let x = [];
let x = Data::new(x);
assert!(x.variance().unwrap().is_nan());

let y = [0.0, f64::NAN, 3.0, -2.0];
let y = Data::new(y);
assert!(y.variance().unwrap().is_nan());

let z = [0.0, 3.0, -2.0];
let z = Data::new(z);
assert_eq!(z.variance().unwrap(), 19.0 / 3.0);

fn std_dev(&self) -> Option<T>

Returns the standard deviation, if it exists.

fn entropy(&self) -> Option<T>

Returns the entropy, if it exists.

fn skewness(&self) -> Option<T>

Returns the skewness, if it exists.

impl<D: AsRef<[f64]>> Index<usize> for Data<D>

type Output = f64

The returned type after indexing.

fn index(&self, i: usize) -> &f64

Performs the indexing (container[index]) operation.

impl<D: AsMut<[f64]> + AsRef<[f64]>> IndexMut<usize> for Data<D>

fn index_mut(&mut self, i: usize) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl<D: AsMut<[f64]> + AsRef<[f64]>> Max<f64> for Data<D>

fn max(&self) -> f64

Returns the maximum value in the data

Remarks

Returns f64::NAN if data is empty or an entry is f64::NAN

Examples

use statrs::statistics::Max;
use statrs::statistics::Data;

let x = [];
let x = Data::new(x);
assert!(x.max().is_nan());

let y = [0.0, f64::NAN, 3.0, -2.0];
let y = Data::new(y);
assert!(y.max().is_nan());

let z = [0.0, 3.0, -2.0];
let z = Data::new(z);
assert_eq!(z.max(), 3.0);

impl<D: AsMut<[f64]> + AsRef<[f64]> + Clone> Median<f64> for Data<D>

fn median(&self) -> f64

Returns the median value from the data

Remarks

Returns f64::NAN if data is empty

Examples

use statrs::statistics::Median;
use statrs::statistics::Data;

let x = [];
let x = Data::new(x);
assert!(x.median().is_nan());

let y = [0.0, 3.0, -2.0];
let y = Data::new(y);
assert_eq!(y.median(), 0.0);

impl<D: AsMut<[f64]> + AsRef<[f64]>> Min<f64> for Data<D>

fn min(&self) -> f64

Returns the minimum value in the data

Remarks

Returns f64::NAN if data is empty or an entry is f64::NAN

Examples

use statrs::statistics::Min;
use statrs::statistics::Data;

let x = [];
let x = Data::new(x);
assert!(x.min().is_nan());

let y = [0.0, f64::NAN, 3.0, -2.0];
let y = Data::new(y);
assert!(y.min().is_nan());

let z = [0.0, 3.0, -2.0];
let z = Data::new(z);
assert_eq!(z.min(), -2.0);

impl<D: AsMut<[f64]> + AsRef<[f64]>> OrderStatistics<f64> for Data<D>

fn order_statistic(&mut self, order: usize) -> f64

Returns the order statistic (order 1..N) from the data

fn median(&mut self) -> f64

Returns the median value from the data

fn quantile(&mut self, tau: f64) -> f64

Estimates the tau-th quantile from the data. The tau-th quantile is the data value where the cumulative distribution function crosses tau.

fn percentile(&mut self, p: usize) -> f64

Estimates the p-Percentile value from the data.

fn lower_quartile(&mut self) -> f64

Estimates the first quartile value from the data.

fn upper_quartile(&mut self) -> f64

Estimates the third quartile value from the data.

fn interquartile_range(&mut self) -> f64

Estimates the inter-quartile range from the data.

fn ranks(&mut self, tie_breaker: RankTieBreaker) -> Vec<f64>

Evaluates the rank of each entry of the data.

impl<D: PartialEq> PartialEq for Data<D>

fn eq(&self, other: &Data<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: Eq> Eq for Data<D>

impl<D> StructuralPartialEq for Data<D>