Struct rv::dist::Skellam

pub struct Skellam { /* private fields */ }

Skellam distribution over x in {.., -2, -1, 0, 1, … }.

Example

use rv::prelude::*;

// Create Skellam(μ_1=5.3, μ_2=2.5)
let skel = Skellam::new(5.3, 2.5).unwrap();

// Draw 100 samples
let mut rng = rand::thread_rng();
let xs: Vec<i32> = skel.sample(100, &mut rng);
assert_eq!(xs.len(), 100)

Implementations

impl Skellam

pub fn new(mu_1: f64, mu_2: f64) -> Result<Self, SkellamError>

Create a new Skellam distribution with given rates

pub fn new_unchecked(mu_1: f64, mu_2: f64) -> Self

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

pub fn mu_1(&self) -> f64

Get the mu_1 parameter

Example

let skel = Skellam::new(2.0, 3.0).unwrap();
assert_eq!(skel.mu_1(), 2.0);

pub fn set_mu_1(&mut self, mu_1: f64) -> Result<(), SkellamError>

Set the mu_1 (first rate) parameter

Example

use rv::dist::Skellam;
let mut skel = Skellam::new(2.0, 1.0).unwrap();
assert_eq!(skel.mu_1(), 2.0);

skel.set_mu_1(1.1).unwrap();
assert_eq!(skel.mu_1(), 1.1);

Will error for invalid values

assert!(skel.set_mu_1(1.1).is_ok());
assert!(skel.set_mu_1(0.0).is_err());
assert!(skel.set_mu_1(-1.0).is_err());
assert!(skel.set_mu_1(std::f64::INFINITY).is_err());
assert!(skel.set_mu_1(std::f64::NEG_INFINITY).is_err());
assert!(skel.set_mu_1(std::f64::NAN).is_err());

pub fn set_mu_1_unchecked(&mut self, mu_1: f64)

Set the mu_1 (first rate) parameter without input validation

pub fn mu_2(&self) -> f64

Get the mu_2 parameter

Example

let skel = Skellam::new(2.0, 3.0).unwrap();
assert_eq!(skel.mu_2(), 3.0);

pub fn set_mu_2(&mut self, mu_2: f64) -> Result<(), SkellamError>

Set the mu_2 (second rate) parameter

Example

use rv::dist::Skellam;
let mut skel = Skellam::new(2.0, 1.0).unwrap();
assert_eq!(skel.mu_2(), 1.0);

skel.set_mu_2(1.1).unwrap();
assert_eq!(skel.mu_2(), 1.1);

Will error for invalid values

assert!(skel.set_mu_2(1.1).is_ok());
assert!(skel.set_mu_2(0.0).is_err());
assert!(skel.set_mu_2(-1.0).is_err());
assert!(skel.set_mu_2(std::f64::INFINITY).is_err());
assert!(skel.set_mu_2(std::f64::NEG_INFINITY).is_err());
assert!(skel.set_mu_2(std::f64::NAN).is_err());

pub fn set_mu_2_unchecked(&mut self, mu_2: f64)

Set the mu_2 (first rate) parameter without input validation

pub fn set_cache_cap(&self, cap: usize)

Set the cache size on the internal LRU for Bessel Iv calls.

Panics

Panics if cap is 0.

Trait Implementations

impl Clone for Skellam

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Skellam

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Skellam

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DiscreteDistr<i16> for Skellam

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl DiscreteDistr<i32> for Skellam

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl DiscreteDistr<i8> for Skellam

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl Display for Skellam

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

Formats the value using the given formatter.

impl From<&Skellam> for String

fn from(skellam: &Skellam) -> String

Converts to this type from the input type.

impl Kurtosis for Skellam

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

impl Mean<f64> for Skellam

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

Returns None if the mean is undefined

impl PartialEq for Skellam

fn eq(&self, other: &Skellam) -> 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 Rv<i16> for Skellam

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

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

Probability function

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 Rv<i32> for Skellam

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

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

Probability function

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 Rv<i8> for Skellam

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

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

Probability function

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 Skellam

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 Skellam

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

impl Support<i16> for Skellam

fn supports(&self, _x: &i16) -> bool

Returns true if x is in the support of the Rv

impl Support<i32> for Skellam

fn supports(&self, _x: &i32) -> bool

Returns true if x is in the support of the Rv

impl Support<i8> for Skellam

fn supports(&self, _x: &i8) -> bool

Returns true if x is in the support of the Rv

impl Variance<f64> for Skellam

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

Returns None if the variance is undefined