Struct Normal 

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

Normal (Gaussian) distribution N(μ, σ²).

Example

use numeris::stats::{Normal, ContinuousDistribution};

let n = Normal::new(0.0_f64, 1.0).unwrap();
assert!((n.cdf(0.0) - 0.5).abs() < 1e-14);
assert!((n.quantile(0.975) - 1.96).abs() < 0.01);

Implementations

impl<T: FloatScalar> Normal<T>

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

Create a normal distribution with mean mu and standard deviation sigma.

Requires sigma > 0.

Examples found in repository

docs/examples/gen_plots.rs (line 513)

fn make_normal_pdf_plot() -> String {
    let dists: Vec<(Normal<f64>, &str)> = vec![
        (Normal::new(0.0, 1.0).unwrap(), "μ=0, σ=1"),
        (Normal::new(0.0, 2.0).unwrap(), "μ=0, σ=2"),
        (Normal::new(2.0, 0.7).unwrap(), "μ=2, σ=0.7"),
    ];

    const N: usize = 300;
    let x_min = -6.0_f64;
    let x_max = 6.0_f64;
    let mut xv: Vec<f64> = (0..N)
        .map(|i| x_min + (x_max - x_min) * i as f64 / (N - 1) as f64)
        .collect();
    // ensure exact 0
    xv[N / 2] = 0.0;

    let traces: Vec<String> = dists
        .iter()
        .map(|(d, name)| {
            let yv: Vec<f64> = xv.iter().map(|&x| d.pdf(x)).collect();
            line_trace(name, &xv, &yv)
        })
        .collect();

    let layout = decorate_layout("Normal Distribution — PDF", "x", "f(x)", "");
    plotly_snippet("plot-normal-pdf", &format!("[{}]", traces.join(",")), &layout, 400)
}

fn make_gamma_pdf_plot() -> String {
    let dists: Vec<(Gamma<f64>, &str)> = vec![
        (Gamma::new(1.0, 1.0).unwrap(), "α=1, β=1 (Exp)"),
        (Gamma::new(2.0, 1.0).unwrap(), "α=2, β=1"),
        (Gamma::new(5.0, 1.0).unwrap(), "α=5, β=1"),
        (Gamma::new(2.0, 2.0).unwrap(), "α=2, β=2"),
    ];

    const N: usize = 300;
    let x_min = 0.01_f64;
    let x_max = 12.0_f64;
    let xv: Vec<f64> = (0..N)
        .map(|i| x_min + (x_max - x_min) * i as f64 / (N - 1) as f64)
        .collect();

    let traces: Vec<String> = dists
        .iter()
        .map(|(d, name)| {
            let yv: Vec<f64> = xv.iter().map(|&x| d.pdf(x)).collect();
            line_trace(name, &xv, &yv)
        })
        .collect();

    let layout = decorate_layout("Gamma Distribution — PDF", "x", "f(x)", "");
    plotly_snippet("plot-gamma-pdf", &format!("[{}]", traces.join(",")), &layout, 400)
}

fn make_beta_pdf_plot() -> String {
    let dists: Vec<(Beta<f64>, &str)> = vec![
        (Beta::new(0.5, 0.5).unwrap(), "α=0.5, β=0.5"),
        (Beta::new(2.0, 2.0).unwrap(), "α=2, β=2"),
        (Beta::new(2.0, 5.0).unwrap(), "α=2, β=5"),
        (Beta::new(5.0, 2.0).unwrap(), "α=5, β=2"),
    ];

    const N: usize = 300;
    let eps = 0.005;
    let xv: Vec<f64> = (0..N)
        .map(|i| eps + (1.0 - 2.0 * eps) * i as f64 / (N - 1) as f64)
        .collect();

    let traces: Vec<String> = dists
        .iter()
        .map(|(d, name)| {
            let yv: Vec<f64> = xv.iter().map(|&x| d.pdf(x).min(8.0)).collect();
            line_trace(name, &xv, &yv)
        })
        .collect();

    let layout = decorate_layout_ex(
        "Beta Distribution — PDF",
        "x",
        "",
        "f(x)",
        ",\"range\":[0,4.5]",
        "",
    );
    plotly_snippet("plot-beta-pdf", &format!("[{}]", traces.join(",")), &layout, 400)
}

// ─── Stats: discrete PMF plots ───────────────────────────────────────────

fn make_binomial_pmf_plot() -> String {
    let dists: Vec<(Binomial<f64>, &str)> = vec![
        (Binomial::new(10, 0.3).unwrap(), "n=10, p=0.3"),
        (Binomial::new(10, 0.5).unwrap(), "n=10, p=0.5"),
        (Binomial::new(20, 0.7).unwrap(), "n=20, p=0.7"),
    ];

    let k_max = 21u64;
    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(
        "Binomial Distribution — PMF",
        "k",
        "",
        "P(X = k)",
        "",
        ",\"barmode\":\"group\"",
    );
    plotly_snippet("plot-binomial-pmf", &format!("[{}]", traces.join(",")), &layout, 400)
}

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)
}

fn make_continuous_cdf_plot() -> String {
    let normal = Normal::new(0.0, 1.0).unwrap();
    let gamma = Gamma::new(3.0, 1.0).unwrap();
    let beta = Beta::new(2.0, 5.0).unwrap();

    const N: usize = 300;

    // Normal CDF on [-4, 4]
    let xn: Vec<f64> = (0..N)
        .map(|i| -4.0 + 8.0 * i as f64 / (N - 1) as f64)
        .collect();
    let yn: Vec<f64> = xn.iter().map(|&x| normal.cdf(x)).collect();

    // Gamma CDF on [0, 10]
    let xg: Vec<f64> = (0..N)
        .map(|i| 0.01 + 10.0 * i as f64 / (N - 1) as f64)
        .collect();
    let yg: Vec<f64> = xg.iter().map(|&x| gamma.cdf(x)).collect();

    // Beta CDF on [0, 1]
    let xb: Vec<f64> = (0..N)
        .map(|i| 0.005 + 0.99 * i as f64 / (N - 1) as f64)
        .collect();
    let yb: Vec<f64> = xb.iter().map(|&x| beta.cdf(x)).collect();

    let traces = format!(
        "[{},{},{}]",
        line_trace("Normal(0, 1)", &xn, &yn),
        line_trace("Gamma(3, 1)", &xg, &yg),
        line_trace("Beta(2, 5)", &xb, &yb),
    );

    let layout = decorate_layout(
        "Continuous Distributions — CDF",
        "x",
        "F(x)",
        "",
    );
    plotly_snippet("plot-continuous-cdf", &traces, &layout, 400)
}

impl<T: FloatScalar> Normal<T>

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

Draw a random sample from this distribution.

Example

use numeris::stats::{Normal, Rng};

let n = Normal::new(0.0_f64, 1.0).unwrap();
let mut rng = Rng::new(42);
let x = n.sample(&mut rng);
// x is drawn from N(0, 1)

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

Fill a fixed-size array with independent samples.

Trait Implementations

impl<T: Clone> Clone for Normal<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: FloatScalar> ContinuousDistribution<T> for Normal<T>

fn pdf(&self, x: T) -> T

Probability density function.

fn ln_pdf(&self, x: T) -> T

Natural log of the probability density function.

fn cdf(&self, x: T) -> T

Cumulative distribution function P(X ≤ x).

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

Quantile function (inverse CDF). Returns x such that P(X ≤ x) = p.

fn mean(&self) -> T

Expected value E[X].

fn variance(&self) -> T

Variance Var(X).

impl<T: Debug> Debug for Normal<T>

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

Formats the value using the given formatter.

impl<T: Copy> Copy for Normal<T>