Struct rv::dist::UnitPowerLaw

pub struct UnitPowerLaw { /* private fields */ }

UnitPowerLaw(α) over x in (0, 1).

Examples

UnitPowerLaw as a conjugate prior for Bernoulli

use rv::prelude::*;

// A prior that encodes our strong belief that coins are fair:
let powlaw = UnitPowerLaw::new(5.0).unwrap();

Implementations

impl UnitPowerLaw

pub fn new(alpha: f64) -> Result<Self, UnitPowerLawError>

Create a UnitPowerLaw distribution with even density over (0, 1).

Example

// Uniform
let powlaw_unif = UnitPowerLaw::new(1.0);
assert!(powlaw_unif.is_ok());

// Invalid negative parameter
let powlaw_nope  = UnitPowerLaw::new(-5.0);
assert!(powlaw_nope.is_err());

pub fn new_unchecked(alpha: f64) -> Self

Creates a new UnitPowerLaw without checking whether the parameters are valid.

pub fn uniform() -> Self

Create a UnitPowerLaw distribution with even density over (0, 1).

Example

let powlaw = UnitPowerLaw::uniform();
assert_eq!(powlaw, UnitPowerLaw::new(1.0).unwrap());

pub fn alpha(&self) -> f64

Get the alpha parameter

Example

let powlaw = UnitPowerLaw::new(5.0).unwrap();
assert_eq!(powlaw.alpha(), 5.0);

pub fn set_alpha(&mut self, alpha: f64) -> Result<(), UnitPowerLawError>

Set the alpha parameter

Example

let mut powlaw = UnitPowerLaw::new(5.0).unwrap();

powlaw.set_alpha(2.0).unwrap();
assert_eq!(powlaw.alpha(), 2.0);

Will error for invalid values

assert!(powlaw.set_alpha(0.1).is_ok());
assert!(powlaw.set_alpha(0.0).is_err());
assert!(powlaw.set_alpha(-1.0).is_err());
assert!(powlaw.set_alpha(f64::INFINITY).is_err());
assert!(powlaw.set_alpha(f64::NAN).is_err());

pub fn set_alpha_unchecked(&mut self, alpha: f64)

Set alpha without input validation

pub fn alpha_inv(&self) -> f64

Evaluate or fetch cached ln(a*b)

pub fn alpha_ln(&self) -> f64

Evaluate or fetch cached ln(a*b)

Trait Implementations

impl Cdf<f32> for UnitPowerLaw

fn cdf(&self, x: &f32) -> f64

The value of the Cumulative Density Function at x

fn sf(&self, x: &X) -> f64

Survival function, 1 - CDF(x)

impl Cdf<f64> for UnitPowerLaw

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

The value of the Cumulative Density Function at x

fn sf(&self, x: &X) -> f64

Survival function, 1 - CDF(x)

impl Clone for UnitPowerLaw

fn clone(&self) -> UnitPowerLaw

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X: Booleable> ConjugatePrior<X, Bernoulli> for UnitPowerLaw

type Posterior = Beta

Type of the posterior distribution

type MCache = f64

Type of the cache for the marginal likelihood

type PpCache = (f64, f64)

Type of the cache for the posterior predictive

fn posterior(&self, x: &DataOrSuffStat<'_, X, Bernoulli>) -> Beta

fn ln_m_cache(&self) -> Self::MCache

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::MCache, x: &DataOrSuffStat<'_, X, Bernoulli>, ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, X, Bernoulli>) -> Self::PpCache

Compute the cache for the Log posterior predictive of y given x.

fn ln_pp_with_cache(&self, cache: &Self::PpCache, y: &X) -> f64

Log posterior predictive of y given x with supplied ln(norm)

fn posterior_from_suffstat(&self, stat: &Fx::Stat) -> Self::Posterior

Computes the posterior distribution from the data

fn ln_m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

The log marginal likelihood

fn ln_pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Log posterior predictive of y given x

fn m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Marginal likelihood of x

fn pp_with_cache(&self, cache: &Self::PpCache, y: &X) -> f64

fn pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Posterior Predictive distribution

impl ContinuousDistr<Bernoulli> for UnitPowerLaw

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl ContinuousDistr<f32> for UnitPowerLaw

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl ContinuousDistr<f64> for UnitPowerLaw

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl Debug for UnitPowerLaw

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

Formats the value using the given formatter.

impl Default for UnitPowerLaw

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UnitPowerLaw

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for UnitPowerLaw

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

Formats the value using the given formatter.

impl Entropy for UnitPowerLaw

fn entropy(&self) -> f64

The entropy, H(X)

impl From<&UnitPowerLaw> for Beta

fn from(powlaw: &UnitPowerLaw) -> Beta

Converts to this type from the input type.

impl From<&UnitPowerLaw> for String

fn from(powlaw: &UnitPowerLaw) -> String

Converts to this type from the input type.

impl HasDensity<Bernoulli> for UnitPowerLaw

fn ln_f(&self, x: &Bernoulli) -> f64

Probability function

fn f(&self, x: &X) -> f64

Probability function

impl HasDensity<f32> for UnitPowerLaw

fn ln_f(&self, x: &f32) -> f64

Probability function

fn f(&self, x: &X) -> f64

Probability function

impl HasDensity<f64> for UnitPowerLaw

fn ln_f(&self, x: &f64) -> f64

Probability function

fn f(&self, x: &X) -> f64

Probability function

impl HasSuffStat<f32> for UnitPowerLaw

type Stat = UnitPowerLawSuffStat

fn empty_suffstat(&self) -> Self::Stat

fn ln_f_stat(&self, stat: &Self::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl HasSuffStat<f64> for UnitPowerLaw

type Stat = UnitPowerLawSuffStat

fn empty_suffstat(&self) -> Self::Stat

fn ln_f_stat(&self, stat: &Self::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl InverseCdf<f32> for UnitPowerLaw

fn invcdf(&self, p: f64) -> f32

The value of the x at the given probability in the CDF

fn quantile(&self, p: f64) -> X

Alias for invcdf

fn interval(&self, p: f64) -> (X, X)

Interval containing p proportion for the probability

impl InverseCdf<f64> for UnitPowerLaw

fn invcdf(&self, p: f64) -> f64

The value of the x at the given probability in the CDF

fn quantile(&self, p: f64) -> X

Alias for invcdf

fn interval(&self, p: f64) -> (X, X)

Interval containing p proportion for the probability

impl Kurtosis for UnitPowerLaw

fn kurtosis(&self) -> Option<f64>

impl Mean<f32> for UnitPowerLaw

fn mean(&self) -> Option<f32>

Returns None if the mean is undefined

impl Mean<f64> for UnitPowerLaw

fn mean(&self) -> Option<f64>

Returns None if the mean is undefined

impl Mode<f32> for UnitPowerLaw

fn mode(&self) -> Option<f32>

Returns None if the mode is undefined or is not a single value

impl Mode<f64> for UnitPowerLaw

fn mode(&self) -> Option<f64>

Returns None if the mode is undefined or is not a single value

impl Parameterized for UnitPowerLaw

type Parameters = f64

fn emit_params(&self) -> Self::Parameters

fn from_params(alpha: Self::Parameters) -> Self

impl PartialEq for UnitPowerLaw

fn eq(&self, other: &UnitPowerLaw) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sampleable<Bernoulli> for UnitPowerLaw

fn draw<R: Rng>(&self, rng: &mut R) -> Bernoulli

Single draw from the Rv

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<X>

Multiple draws of the Rv

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R, ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl Sampleable<f32> for UnitPowerLaw

fn draw<R: Rng>(&self, rng: &mut R) -> f32

Single draw from the Rv

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<f32>

Multiple draws of the Rv

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R, ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl Sampleable<f64> for UnitPowerLaw

fn draw<R: Rng>(&self, rng: &mut R) -> f64

Single draw from the Rv

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<f64>

Multiple draws of the Rv

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R, ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl Serialize for UnitPowerLaw

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Skewness for UnitPowerLaw

fn skewness(&self) -> Option<f64>

impl Support<Bernoulli> for UnitPowerLaw

fn supports(&self, x: &Bernoulli) -> bool

Returns true if x is in the support of the Rv

impl Support<f32> for UnitPowerLaw

fn supports(&self, x: &f32) -> bool

Returns true if x is in the support of the Rv

impl Support<f64> for UnitPowerLaw

fn supports(&self, x: &f64) -> bool

Returns true if x is in the support of the Rv

impl Variance<f64> for UnitPowerLaw

fn variance(&self) -> Option<f64>

Returns None if the variance is undefined