Struct mathru::statistics::distrib::LogNormal

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

Log-Normal distribution

Fore more information: https://en.wikipedia.org/wiki/Log-normal_distribution

Implementations

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

pub fn new(mu: T, sigma_squared: T) -> Self

Creates a probability distribution

Arguments

• mu:
• sigma_squared:

Panics

if sigma_squared <= 0.0

Example

use mathru::statistics::distrib::LogNormal;

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

pub fn from_data<'a>(_data: &'a Vec<T>) -> Self

It is assumed that data are normal distributed.

data.len() >= 2

Trait Implementations

impl<T: Clone> Clone for LogNormal<T>

pub fn clone(&self) -> LogNormal<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 LogNormal<T> where
    T: Real + Error + Gamma, 

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

Probability density function

Arguments

• x: x ∈ &#x2115

Example

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

let distrib: LogNormal<f64> = LogNormal::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:

Example

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

let distrib: LogNormal<f64> = LogNormal::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

Panics

if p <= 0.0 || p >= 1.0

pub fn mean(&self) -> T

Expected value

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, LogNormal},
};

let distrib: LogNormal<f64> = LogNormal::new(0.0, 0.2);
let mean: f64 = distrib.mean();

pub fn variance(&self) -> T

Variance

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, LogNormal},
};

let sigma_squared: f64 = 0.2;
let distrib: LogNormal<f64> = LogNormal::new(0.0, sigma_squared);
let var: f64 = distrib.variance();
assert_eq!((sigma_squared.exp() - 1.0) * sigma_squared.exp(),  var )

pub fn median(&self) -> T

Median

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, LogNormal},
};

let mu: f64 = 0.0;

let distrib: LogNormal<f64> = LogNormal::new(mu, 0.2);
let median: f64 = distrib.median();
assert_eq!(median, 1.0);

pub fn skewness(&self) -> T

Skewness

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, LogNormal},
};
let mu: f64 = 1.0;
let sigma_squared: f64 = 0.5;
let distrib: LogNormal<f64> = LogNormal::new(mu, sigma_squared);

pub fn entropy(&self) -> T

Entropy

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, LogNormal},
};

let mu: f64 = 1.0;
let sigma_squared: f64 = 0.5;
let distrib: LogNormal<f64> = LogNormal::new(mu, sigma_squared);

impl<T: Copy> Copy for LogNormal<T>

impl<T: Debug> Debug for LogNormal<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for LogNormal<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> Distribution<T> for LogNormal<T> where
    T: Real, 

pub fn random(&self) -> T

pub fn random_sequence(&self, size: u32) -> Vec<T>

impl<T> Serialize for LogNormal<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.