Struct mathru::statistics::distrib::T

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

T distribution

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

Implementations

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

pub fn new(n: K) -> T<K>

Create a probability distribution

Arguments

• n: > 0.0

Panics

if n <= 0.0

Example

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

let distrib: T<f64> = T::new(1.2);

Trait Implementations

impl<K: Clone> Clone for T<K>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Probability density function

Arguments

• x Random variable x &isin ࡃ

Example

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

let distrib: T<f64> = T::new(2.0);
let x: f64 = 0.5;
let p: f64 = distrib.pdf(x);

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

Cumulative distribution function

Arguments

• x Random variable

Example

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

let distrib: T<f64> = T::new(1.3);
let x: f64 = 0.4;
let p: f64 = distrib.cdf(x);

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

Quantile function of inverse cdf

pub fn mean(&self) -> K

Expected value

Panics

if self.n <= 1.0

Example

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

let distrib: T<f64> = T::new(1.2);
let mean: f64 = distrib.mean();

pub fn variance(&self) -> K

Variance

Example

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

let distrib: T<f64> = T::new(2.2);
let var: f64 = distrib.variance();

pub fn skewness(&self) -> K

Panics

if self.n <= 3

pub fn median(&self) -> K

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

pub fn entropy(&self) -> K

impl<K: Copy> Copy for T<K>

impl<K: Debug> Debug for T<K>

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

Formats the value using the given formatter.

impl<'de, K> Deserialize<'de> for T<K> where
    K: 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<K> Serialize for T<K> where
    K: Serialize, 

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

Serialize this value into the given Serde serializer.