Struct Poisson 

pub struct Poisson { /* private fields */ }

A discrete distribution for modeling the number of events occurring in a fixed interval.

Returns u64 for natural counting arithmetic.

Mathematical Properties:

• Support: {0, 1, 2, 3, …}
• PMF: P(X = k) = (λ^k × e^(-λ)) / k!
• Mean: λ
• Variance: λ
• Memoryless: Past events don’t affect future rates

Example:

// Model event counts
let events = sample(addr!("events"), Poisson::new(3.0).unwrap())
    .bind(|count| {
        let status = match count {
            0 => "No events",
            1 => "Single event",
            n if n > 10 => "High activity",
            _ => "Normal activity"
        };
        pure(status.to_string())
    });

// Hierarchical model with Gamma prior
let hierarchical = sample(addr!("rate"), Gamma::new(2.0, 1.0).unwrap())
    .bind(|lambda| sample(addr!("count"), Poisson::new(lambda).unwrap()));

// Observe count data
let observed = observe(addr!("observed_count"), Poisson::new(4.0).unwrap(), 7u64);

Implementations

impl Poisson

pub fn new(lambda: f64) -> FugueResult<Self>

Create a new Poisson distribution with validated parameters.

pub fn lambda(&self) -> f64

Get the rate parameter.

Trait Implementations

impl Clone for Poisson

fn clone(&self) -> Poisson

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Poisson

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

Formats the value using the given formatter.

impl Distribution<u64> for Poisson

fn sample(&self, rng: &mut dyn RngCore) -> u64

Generate a random sample (with its natural type), T, from the distribution, using the provided random number generator, rng.

fn log_prob(&self, x: &u64) -> LogF64

Compute the log-probability density (continuous) or mass (discrete) of a value, x, from the distribution.

fn clone_box(&self) -> Box<dyn Distribution<u64>>

Clone the distribution into a boxed trait object, Box<dyn Distribution<T>>.

impl Copy for Poisson