Struct mathru::statistics::distrib::Poisson

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

Poisson distribution

Fore more information: https://en.wikipedia.org/wiki/Poisson_distribution

Implementations

impl<T> Poisson<T> where
    T: Real, 

pub fn new(gamma: &T) -> Poisson<T>

Creates a probability distribution

Arguments

• gamma gamma > 0.0

Panics

if gamma <= 0.0

Example

use mathru::statistics::distrib::Poisson;

let distrib: Poisson<f64> = Poisson::new(&0.2);

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Poisson<T> where
    T: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Discrete<T, u32, u32> for Poisson<T> where
    T: Real + Gamma, 

pub fn pmf<'a>(&'a self, x: u32) -> T

Probability mass function

Arguments

• x Random variable x ∈ ℕ

Example

use mathru::statistics::distrib::{Discrete, Poisson};

let distrib: Poisson<f64> = Poisson::new(&0.2);
let x: u32 = 5;
let p: f64 = distrib.pmf(x);

pub fn cdf<'a>(&'a self, x: u32) -> T

Cumulative distribution function of the Bernoulli distribution

Arguments

• x Random variable x ∈ ℕ

Example

use mathru::statistics::distrib::{Discrete, Poisson};

let distrib: Poisson<f64> = Poisson::new(&0.2);
let x: u32 = 4;
let p: f64 = distrib.cdf(x);

pub fn mean<'a>(&'a self) -> T

Expected value

Example

use mathru::statistics::distrib::{Discrete, Poisson};

let distrib: Poisson<f64> = Poisson::new(&0.2);
let mean: f64 = distrib.mean();

pub fn variance<'a>(&'a self) -> T

Variance

Example

use mathru::statistics::distrib::{Discrete, Poisson};

let distrib: Poisson<f64> = Poisson::new(&0.2);
let var: f64 = distrib.variance();

impl<T> Serialize for Poisson<T> where
    T: Serialize, 

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.