Struct Shifted 

pub struct Shifted<D> { /* private fields */ }

A wrapper for distributions that adds a shift parameter

Example

use rv::prelude::*;
use rv::dist::{Shifted, Gaussian};

let shifted = Shifted::new(Gaussian::standard(), 5.0).expect("Valid Input");

assert_eq!(shifted.mean(), Some(5.0));
assert_eq!(shifted.variance(), Some(1.0));

Implementations

impl<D> Shifted<D>

pub fn new(parent: D, shift: f64) -> Result<Self, ShiftedError>

Create a new shifted distribution with a given parent distribution and a offset parameter.

Example

use rv::prelude::*;

let _ok = Shifted::new(Gaussian::standard(), 5.0).unwrap();
let _err = Shifted::new(Gaussian::standard(), f64::INFINITY);

pub fn new_unchecked(parent: D, shift: f64) -> Self

Create a new Shifted distribution without checking the shift parameter is finite.

pub fn shift(&self) -> f64

Extract the shift from a given Shifted distribution

Example

use rv::prelude::*;

let dist = Shifted::new(Gaussian::standard(), 5.0).unwrap();

assert_eq!(dist.shift(), 5.0);

Trait Implementations

impl<D> Cdf<f64> for Shifted<D>

where D: Cdf<f64>,

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl<D: Clone> Clone for Shifted<D>

fn clone(&self) -> Shifted<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Pr, Fx> ConjugatePrior<f64, Shifted<Fx>> for ShiftedPrior<Pr, Fx>

where Pr: ConjugatePrior<f64, Fx, Posterior = Pr>, Fx: HasSuffStat<f64> + Shiftable + HasDensity<f64>, Shifted<Fx>: HasSuffStat<f64, Stat = ShiftedSuffStat<Fx::Stat>>,

type Posterior = ShiftedPrior<Pr, Fx>

Type of the posterior distribution

type MCache = <Pr as ConjugatePrior<f64, Fx>>::MCache

Type of the cache for the marginal likelihood

type PpCache = <Pr as ConjugatePrior<f64, Fx>>::PpCache

Type of the cache for the posterior predictive

fn empty_stat(&self) -> ShiftedSuffStat<Fx::Stat>

Generate and empty sufficient statistic

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

Computes the posterior distribution from the data

fn posterior(&self, x: &DataOrSuffStat<'_, f64, Shifted<Fx>>) -> Self::Posterior

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<'_, f64, Shifted<Fx>>, ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, f64, Shifted<Fx>>) -> Self::PpCache

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

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

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

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<D> ContinuousDistr<f64> for Shifted<D>

where D: ContinuousDistr<f64>,

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<D: Debug> Debug for Shifted<D>

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

Formats the value using the given formatter.

impl<'de, D> Deserialize<'de> for Shifted<D>

where D: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<D> Entropy for Shifted<D>

where D: Entropy,

fn entropy(&self) -> f64

The entropy, H(X)

impl<D> HasDensity<f64> for Shifted<D>

where D: HasDensity<f64>,

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

Probability function

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

Probability function

impl<D> HasSuffStat<f64> for Shifted<D>

where D: HasSuffStat<f64>,

type Stat = ShiftedSuffStat<<D as HasSuffStat<f64>>::Stat>

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<D> InverseCdf<f64> for Shifted<D>

where D: InverseCdf<f64>,

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

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

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

Interval containing p proportion for the probability

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

Alias for invcdf

impl<D> Kurtosis for Shifted<D>

where D: Kurtosis,

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

impl<D> Mean<f64> for Shifted<D>

where D: Mean<f64>,

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

Returns None if the mean is undefined

impl<D> Median<f64> for Shifted<D>

where D: Median<f64>,

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

Returns None if the median is undefined

impl<D> Mode<f64> for Shifted<D>

where D: Mode<f64>,

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

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

impl<D> Parameterized for Shifted<D>

where D: Parameterized,

type Parameters = ShiftedParameters<D>

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<D: PartialEq> PartialEq for Shifted<D>

fn eq(&self, other: &Shifted<D>) -> 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<Pr, Fx> Sampleable<Shifted<Fx>> for ShiftedPrior<Pr, Fx>

where Pr: Sampleable<Fx>, Fx: Shiftable,

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

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<D> Sampleable<f64> for Shifted<D>

where D: Sampleable<f64>,

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<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<D> Serialize for Shifted<D>

where D: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<D> Shiftable for Shifted<D>

where D: Shiftable,

type Output = Shifted<D>

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<D> Skewness for Shifted<D>

where D: Skewness,

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

impl<D> Support<f64> for Shifted<D>

where D: Support<f64>,

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

Returns true if x is in the support of the Rv

impl<D> Variance<f64> for Shifted<D>

where D: Variance<f64>,

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

Returns None if the variance is undefined

impl<D> StructuralPartialEq for Shifted<D>