Struct Normal 

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

Normal distribution

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

Implementations

impl<T> Normal<T>

where T: Real,

pub fn new(mean: T, variance: T) -> Self

Creates a probability distribution

Arguments

• mean: Expected value
• variance: variance > 0.0

Panics

if variance <= 0.0

Example

use mathru::statistics::distrib::Normal;

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

pub fn from_data(data: &[T]) -> Self

It is assumed that data are normal distributed.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Continuous<T> for Normal<T>

where T: Real + Gamma + Error,

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

Probability density function

Arguments

• x: x ∈ &#x2115

Example

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

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

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

Cumulative distribution function

Arguments

• x:

Example

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

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

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

Quantile: function of inverse cdf

The Percentage Points of the Normal Distribution Author(s): Michael J. Wichura Year 1988 Journal of the Royal Statistical Society 0.0 < p < 1.0

Panics

if p <= 0.0 || p >= 1.0

fn mean(&self) -> T

Expected value

Example

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

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

fn variance(&self) -> T

Variance

Example

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

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

fn skewness(&self) -> T

Skewness

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, Normal},
};
let mean: f64 = 1.0;
let variance: f64 = 0.5;
let distrib: Normal<f64> = Normal::new(mean, variance);
assert_eq!(0.0, distrib.skewness());

fn median(&self) -> T

Median

Example

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

let mean: f64 = 0.0;

let distrib: Normal<f64> = Normal::new(mean, 0.2);
let median: f64 = distrib.median();

fn entropy(&self) -> T

Entropy

Example

use mathru::{
    self,
    statistics::distrib::{Continuous, Normal},
};
use std::f64::consts::{E, PI};

let mean: f64 = 1.0;
let variance: f64 = 0.5;
let distrib: Normal<f64> = Normal::new(mean, variance);

let entropy: f64 =  distrib.entropy();

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

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

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

Formats the value using the given formatter.

impl<T> Distribution<T> for Normal<T>

where T: Real,

fn random(&self) -> T

See Knuth The Art of Computer Programming Vol 2 3.4.1 C Algorithm P

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