Struct Poisson 

pub struct Poisson<T> { /* private fields */ }

Poisson distribution with rate λ.

P(X = k) = λ^k e^{−λ} / k! for k = 0, 1, 2, …

Example

use numeris::stats::{Poisson, DiscreteDistribution};

let p = Poisson::new(3.0_f64).unwrap();
assert!((p.mean() - 3.0).abs() < 1e-14);
assert!((p.variance() - 3.0).abs() < 1e-14);

Implementations

impl<T: FloatScalar> Poisson<T>

pub fn new(lambda: T) -> Result<Self, StatsError>

Create a Poisson distribution with rate lambda. Requires lambda > 0.

Examples found in repository

docs/examples/gen_plots.rs (line 632)

fn make_poisson_pmf_plot() -> String {
    let dists: Vec<(Poisson<f64>, &str)> = vec![
        (Poisson::new(1.0).unwrap(), "λ = 1"),
        (Poisson::new(4.0).unwrap(), "λ = 4"),
        (Poisson::new(10.0).unwrap(), "λ = 10"),
    ];

    let k_max = 20u64;
    let kv: Vec<f64> = (0..=k_max).map(|k| k as f64).collect();

    let traces: Vec<String> = dists
        .iter()
        .map(|(d, name)| {
            let yv: Vec<f64> = (0..=k_max).map(|k| d.pmf(k)).collect();
            bar_trace(name, &kv, &yv)
        })
        .collect();

    let layout = decorate_layout_ex(
        "Poisson Distribution — PMF",
        "k",
        "",
        "P(X = k)",
        "",
        ",\"barmode\":\"group\"",
    );
    plotly_snippet("plot-poisson-pmf", &format!("[{}]", traces.join(",")), &layout, 400)
}

impl<T: FloatScalar> Poisson<T>

pub fn sample(&self, rng: &mut Rng) -> u64

Draw a random sample from this distribution.

For small lambda (< 30), uses Knuth’s algorithm. For large lambda, uses a normal approximation.

pub fn sample_array<const K: usize>(&self, rng: &mut Rng) -> [u64; K]

Fill a fixed-size array with independent samples.

Trait Implementations

impl<T: Clone> Clone for Poisson<T>

fn clone(&self) -> Poisson<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Poisson<T>

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

Formats the value using the given formatter.

impl<T: FloatScalar> DiscreteDistribution<T> for Poisson<T>

fn pmf(&self, k: u64) -> T

Probability mass function P(X = k).

fn ln_pmf(&self, k: u64) -> T

Natural log of the probability mass function.

fn cdf(&self, k: u64) -> T

Cumulative distribution function P(X ≤ k).

fn quantile(&self, p: T) -> u64

Quantile function (inverse CDF). Returns the smallest k such that P(X ≤ k) ≥ p.

fn mean(&self) -> T

Expected value E[X].

fn variance(&self) -> T

Variance Var(X).

impl<T: Copy> Copy for Poisson<T>