Struct tdigest_ch::TDigest

pub struct TDigest { /* private fields */ }

T-digest data structure for approximating the quantiles of a distribution.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();

// Add some elements.
digest.insert(1.0);
digest.insert(2.0);
digest.insert(3.0);

// Get the median of the distribution.
let quantile = digest.quantile(0.5);
assert_eq!(quantile, 2.0);

Implementations

impl TDigest

pub fn new() -> Self

Creates an empty TDigest.

Examples

use tdigest_ch::TDigest;
let digest = TDigest::new();

pub fn builder() -> TDigestBuilder

Creates a TDigestBuilder to configure a TDigest.

This is the same as TDigestBuilder::new().

pub fn append(&mut self, other: &mut TDigest)

Moves all the elements of other into self, leaving other empty.

Examples

use tdigest_ch::TDigest;

let mut a = TDigest::from([-10.0, 1.0, 2.0, 2.0, 3.0]);
let mut b = TDigest::from([-20.0, 5.0, 43.0]);

a.append(&mut b);

assert_eq!(a.len(), 8);
assert!(b.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the t-digest.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();
assert_eq!(digest.len(), 0);
digest.insert(1.0);
assert_eq!(digest.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the t-digest contains no elements.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();
assert!(digest.is_empty());
digest.insert(1.0);
assert!(!digest.is_empty());

pub fn clear(&mut self)

Clears the t-digest, removing all values.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();
digest.insert(1.0);
digest.clear();
assert!(digest.is_empty());

pub fn quantile(&mut self, level: f64) -> f32

Returns the estimated quantile of the t-digest.

This method expects self to be mutable, since the t-digest may be compressed. If you require an immutable, shared reference to compute quantiles, consider using quantiles instead.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::from([1.0, 2.0, 3.0, 4.0, 5.0]);
assert_eq!(digest.quantile(0.0), 1.0);
assert_eq!(digest.quantile(0.5), 3.0);
assert_eq!(digest.quantile(1.0), 5.0);

pub fn quantiles(&mut self) -> Quantiles<'_>

Creates an immutable quantile estimator from the t-digest.

Examples

use std::thread;

use tdigest_ch::TDigest;

let mut digest = TDigest::from([1.0, 2.0, 3.0, 4.0, 5.0]);
let quantiles = digest.quantiles();

thread::scope(|s| {
    s.spawn(|| {
        assert_eq!(quantiles.get(0.0), 1.0);
    });
    s.spawn(|| {
        assert_eq!(quantiles.get(0.5), 3.0);
    });
    s.spawn(|| {
        assert_eq!(quantiles.get(1.0), 5.0);
    });
});

pub fn insert(&mut self, value: f32)

Adds a value to the t-digest.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();

digest.insert(1.0);
digest.insert(2.0);
assert_eq!(digest.len(), 2);

pub fn insert_many(&mut self, value: f32, count: usize)

Adds multiple values to the t-digest.

Examples

use tdigest_ch::TDigest;

let mut digest = TDigest::new();

digest.insert_many(1.0, 1);
digest.insert_many(2.0, 2);
assert_eq!(digest.len(), 3);

Trait Implementations

impl BitOr<&TDigest> for &TDigest

fn bitor(self, rhs: &TDigest) -> TDigest

Returns the union of self and rhs as a new TDigest.

Examples

use tdigest_ch::TDigest;

let a = TDigest::from([1.0, 2.0, 3.0]);
let b = TDigest::from([3.0, 4.0, 5.0]);

let mut c = &a | &b;

assert_eq!(c.len(), 6);
assert_eq!(c.quantile(0.5), 3.0);

type Output = TDigest

The resulting type after applying the | operator.

impl BitOrAssign<&TDigest> for TDigest

fn bitor_assign(&mut self, rhs: &TDigest)

Merges self and rhs into self.

Examples

use tdigest_ch::TDigest;

let mut a = TDigest::from([1.0, 2.0, 3.0]);
let b = TDigest::from([3.0, 4.0, 5.0]);

a |= &b;

assert_eq!(a.len(), 6);
assert_eq!(a.quantile(0.5), 3.0);

impl Clone for TDigest

fn clone(&self) -> TDigest

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TDigest

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

Formats the value using the given formatter.

impl Default for TDigest

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TDigest

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<f32> for TDigest

fn extend<I: IntoIterator<Item = f32>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<const N: usize> From<[f32; N]> for TDigest

fn from(array: [f32; N]) -> Self

Examples

use tdigest_ch::TDigest;

let digest1 = TDigest::from([1.0, 2.0, 3.0, 4.0]);
let digest2: TDigest = [1.0, 2.0, 3.0, 4.0].into();
assert_eq!(digest1, digest2);

impl FromIterator<f32> for TDigest

fn from_iter<I: IntoIterator<Item = f32>>(iter: I) -> Self

Creates a value from an iterator.

impl PartialEq for TDigest

fn eq(&self, other: &TDigest) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for TDigest

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TDigest