Struct BetaPrime 

pub struct BetaPrime { /* private fields */ }

Beta prime distribution, BetaPrime(α, β) over x in (0, ∞).

Examples

use rv::prelude::*;

// Create a beta prime distribution with parameters α=2, β=3
let betaprime = BetaPrime::new(2.0, 3.0).unwrap();

// Calculate some properties
let mean = betaprime.mean().unwrap();
let variance = betaprime.variance().unwrap();

Implementations

impl BetaPrime

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

Create a new BetaPrime distribution with parameters α and β.

Example

let bp = BetaPrime::new(2.0, 3.0);
assert!(bp.is_ok());

// Invalid negative parameter
let bp_nope = BetaPrime::new(-5.0, 1.0);
assert!(bp_nope.is_err());

pub fn new_unchecked(alpha: f64, beta: f64) -> Self

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

pub fn alpha(&self) -> f64

Get the alpha parameter

Example

let bp = BetaPrime::new(2.0, 3.0).unwrap();
assert_eq!(bp.alpha(), 2.0);

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

Set the alpha parameter

Example

let mut bp = BetaPrime::new(2.0, 3.0).unwrap();

bp.set_alpha(2.5).unwrap();
assert_eq!(bp.alpha(), 2.5);

Will error for invalid values

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

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

Set alpha without input validation

pub fn beta(&self) -> f64

Get the beta parameter

Example

let bp = BetaPrime::new(2.0, 3.0).unwrap();
assert_eq!(bp.beta(), 3.0);

pub fn set_beta(&mut self, beta: f64) -> Result<(), BetaPrimeError>

Set the beta parameter

Example

let mut bp = BetaPrime::new(2.0, 3.0).unwrap();

bp.set_beta(3.5).unwrap();
assert_eq!(bp.beta(), 3.5);

Will error for invalid values

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

pub fn set_beta_unchecked(&mut self, beta: f64)

Set beta without input validation

Trait Implementations

impl Cdf<f64> for BetaPrime

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 BetaPrime

fn clone(&self) -> BetaPrime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConjugatePrior<usize, StickBreakingDiscrete> for BetaPrime

Available on crate feature experimental only.

type Posterior = BetaPrime

Type of the posterior distribution

type MCache = f64

Type of the cache for the marginal likelihood

type PpCache = f64

Type of the cache for the posterior predictive

fn empty_stat(&self) -> <StickBreakingDiscrete as HasSuffStat<usize>>::Stat

Generate and empty sufficient statistic

fn posterior( &self, data: &DataOrSuffStat<'_, usize, StickBreakingDiscrete>, ) -> Self

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

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::MCache, data: &DataOrSuffStat<'_, usize, StickBreakingDiscrete>, ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache( &self, data: &DataOrSuffStat<'_, usize, StickBreakingDiscrete>, ) -> Self::PpCache

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

fn ln_pp_with_cache(&self, cache: &Self::PpCache, _y: &usize) -> 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<f64> for BetaPrime

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 BetaPrime

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

Formats the value using the given formatter.

impl Default for BetaPrime

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BetaPrime

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BetaPrime

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

Formats the value using the given formatter.

impl From<&BetaPrime> for String

fn from(bp: &BetaPrime) -> String

Converts to this type from the input type.

impl HasDensity<f64> for BetaPrime

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

Probability function

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

Probability function

impl Mean<f64> for BetaPrime

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

Returns None if the mean is undefined

impl Mode<f64> for BetaPrime

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

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

impl Parameterized for BetaPrime

type Parameters = BetaPrimeParameters

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

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

fn map_params(&self, f: impl Fn(Self::Parameters) -> Self::Parameters) -> Self

impl PartialEq for BetaPrime

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Sampleable<StickBreakingDiscrete> for BetaPrime

Available on crate feature experimental only.

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

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<f64> for BetaPrime

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 Scalable for BetaPrime

type Output = Scaled<BetaPrime>

type Error = ScaledError

fn scaled(self, scale: f64) -> Result<Self::Output, Self::Error>

where Self: Sized,

fn scaled_unchecked(self, scale: f64) -> Self::Output

where Self: Sized,

impl Serialize for BetaPrime

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Shiftable for BetaPrime

type Output = Shifted<BetaPrime>

type Error = ShiftedError

fn shifted(self, shift: f64) -> Result<Self::Output, Self::Error>

where Self: Sized,

fn shifted_unchecked(self, shift: f64) -> Self::Output

where Self: Sized,

impl Support<f64> for BetaPrime

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

Returns true if x is in the support of the Rv

impl Variance<f64> for BetaPrime

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

Returns None if the variance is undefined