Struct Geometric 

pub struct Geometric { /* private fields */ }

The Geometric Distribution

Description

Density, distribution function, quantile function and random generation for the geometric distribution with parameter prob.

Arguments

• x, q: quantiles representing the number of failures in a sequence of Bernoulli trials before success occurs.
• prob: probability of success in each trial. 0 < prob <= 1.

Details

The geometric distribution with prob = p has density

$ p(x) = p (1-p)^x $

for x = 0, 1, 2, …, 0 < p ≤ 1.

If an element of x is not integer, the result of dgeom is zero, with a warning.

The quantile is defined as the smallest value x such that $ F(x) ≥ p $, where F is the distribution function.

Density Plot

let geom = GeometricBuilder::new().build();
let x = <[f64]>::sequence_by(-1.0, 1.0, 0.001);
let y = x
    .iter()
    .map(|x| geom.density(x).unwrap())
    .collect::<Vec<_>>();

let root = SVGBackend::new("density.svg", (1024, 768)).into_drawing_area();
Plot::new()
    .with_options(PlotOptions {
        x_axis_label: "x".to_string(),
        y_axis_label: "density".to_string(),
        ..Default::default()
    })
    .with_plottable(Line {
        x,
        y,
        color: BLACK,
        ..Default::default()
    })
    .plot(&root)
    .unwrap();

Source

dgeom computes via dbinom, using code contributed by Catherine Loader (see dbinom).

pgeom and qgeom are based on the closed-form formulae.

rgeom uses the derivation as an exponential mixture of Poissons, see

Devroye, L. (1986) Non-Uniform Random Variate Generation. Springer-Verlag, New York. Page 480.

See Also

Distributions for other standard distributions, including dnbinom for the negative binomial which generalizes the geometric distribution.

Examples

let x = (1..=9).map(|i| i as f64 / 10.0).collect::<Vec<_>>();

let geom = GeometricBuilder::new()
    .with_success_probability(0.2)
    .build();
let r = x
    .iter()
    .map(|x| geom.quantile(x, true).unwrap())
    .collect::<Vec<_>>();
println!("{r:?}");

let mut rng = MersenneTwister::new();
rng.set_seed(1);

let geom = GeometricBuilder::new()
    .with_success_probability(0.25)
    .build();
let mut r = (0..20)
    .map(|_| geom.random_sample(&mut rng).unwrap() as usize)
    .fold(HashMap::new(), |mut acc, r| {
        *acc.entry(r).or_insert(0) += 1;
        acc
    })
    .into_iter()
    .collect::<Vec<_>>();
r.sort_by(|(i1, _), (i2, _)| i1.cmp(i2));

for (key, index) in &r {
    println!("{key:2}: {index}");
}

Trait Implementations

impl Distribution for Geometric

fn density<R: Into<Real64>>(&self, x: R) -> Real64

The density of the values at a given point

fn log_density<R: Into<Real64>>(&self, x: R) -> Real64

The logarithmic density of the values at a given point

fn probability<R: Into<Real64>>(&self, q: R, lower_tail: bool) -> Probability64

PDF; The probability that a value is found in a distribution (inverse of quantile)

fn log_probability<R: Into<Real64>>( &self, q: R, lower_tail: bool, ) -> LogProbability64

log(PDF); The logarithmic probability that a value is found in a distribution (inverse of quantile)

fn quantile<P: Into<Probability64>>(&self, p: P, lower_tail: bool) -> Real64

The value in the distribution that is associated with a probability (inverse of probability)

fn log_quantile<LP: Into<LogProbability64>>( &self, p: LP, lower_tail: bool, ) -> Real64

The logarithmic value in the distribution that is associated with a probability (inverse of probability)

fn random_sample<R: RNG>(&self, rng: &mut R) -> Real64

Generates a random sample from the distribution