Struct mathru::statistics::distrib::Gamma

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

Gamma distribution

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

Implementations

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

pub fn new(alpha: T, beta: T) -> Gamma<T>

Creates a probability distribution

Arguments

• alpha > 0.0
• beta > 0.0

Panics

if alpha <= 0.0 || beta <= 0.0

Example

use mathru::statistics::distrib::Gamma;

let distrib: Gamma<f64> = Gamma::new(0.3, 0.2);

Trait Implementations

impl<T: Clone> Clone for Gamma<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Continuous<T> for Gamma<T> where
    T: Real + Gamma, 

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

Probability density function

Arguments

• x Random variable x ∈ &#x2115 | x > 0.0

Panics

if x <= 0.0

Example

use mathru::statistics::distrib::{Continuous, Gamma};

let distrib: Gamma<f64> = Gamma::new(0.3, 0.2);
let x: f64 = 5.0;
let p: f64 = distrib.pdf(x);

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

Cumulative distribution function

Arguments

• x Random variable

Example

use mathru::statistics::distrib::{Continuous, Gamma};

let distrib: Gamma<f64> = Gamma::new(0.3, 0.2);
let x: f64 = 0.4;
let p: f64 = distrib.cdf(x);

pub fn quantile(&self, _p: T) -> T

Quantile function of inverse cdf

pub fn mean(&self) -> T

Expected value

pub fn variance(&self) -> T

Variance

Example

use mathru::statistics::distrib::{Continuous, Gamma};

let distrib: Gamma<f64> = Gamma::new(0.2, 0.5);
let var: f64 = distrib.variance();

pub fn skewness(&self) -> T

pub fn median(&self) -> T

Median is the value separating the higher half from the lower half of a probability distribution.

pub fn entropy(&self) -> T

impl<T: Copy> Copy for Gamma<T>

impl<T: Debug> Debug for Gamma<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Gamma<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> Serialize for Gamma<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.