Trait rstat::Distribution

pub trait Distribution {
    type Support: Space;
    fn support(&self) -> Self::Support;
    fn sample<R: Rng + ?Sized>(
        &self, 
        rng: &mut R
    ) -> <Self::Support as Space>::Value;

    fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability { ... }
    fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability { ... }
    fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64 { ... }
    fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64 { ... }
    fn cdf_batch(
        &self, 
        xs: Vector<<Self::Support as Space>::Value>
    ) -> Vector<Probability> { ... }
    fn ccdf_batch(
        &self, 
        xs: Vector<<Self::Support as Space>::Value>
    ) -> Vector<Probability> { ... }
    fn logcdf_batch(
        &self, 
        xs: Vector<<Self::Support as Space>::Value>
    ) -> Vector<f64> { ... }
    fn logccdf_batch(
        &self, 
        xs: Vector<<Self::Support as Space>::Value>
    ) -> Vector<f64> { ... }
    fn sample_n<D, Sh, R: ?Sized>(
        &self, 
        rng: &mut R, 
        shape: Sh
    ) -> Array<<Self::Support as Space>::Value, D>
    where
        D: Dimension,
        Sh: ShapeBuilder<Dim = D>,
        R: Rng,
    { ... }
    fn sample_iter<R>(self, rng: R) -> Sampler<Self, R>
    where
        Self: Sized,
        R: Rng,
    { ... }
}

Associated Types

type Support: Space

Loading content...

Required methods

fn support(&self) -> Self::Support

Returns an instance of the support Space, Self::Support.

fn sample<R: Rng + ?Sized>(
    &self,
    rng: &mut R
) -> <Self::Support as Space>::Value

Loading content...

Provided methods

fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability

Evaluates the cumulative distribution function (CDF) at x.

The CDF is defined as the probability that a random variable X takes on a value less than or equal to x: F(x) = P(X <= x).

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

Evaluates the complementary cumulative distribution function at x.

The complementary CDF is defined as the probability that a random variable X takes on a value strictly greater than x: P(X > x) = 1 - F(x), where F(.) is the CDF.

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

Evaluates the log CDF at x: ln F(x).

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

Evaluates the log complementary CDF at x: ln (1 - F(x)).

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

Evaluates the CDF element-wise for a batch xs.

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

Evaluates the complementary CDF element-wise for a batch xs.

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

Evaluates the log CDF element-wise for a batch xs.

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

Evaluates the log complementary CDF element-wise for a batch xs.

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

Loading content...

Implementors

impl Distribution for BivariateNormal

type Support = PairSpace<Reals, Reals>

fn support(&self) -> PairSpace<Reals, Reals>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> (f64, f64)

fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Dirichlet

type Support = LinearSpace<Interval>

fn support(&self) -> LinearSpace<Interval>

fn cdf(&self, _: Vector<f64>) -> Probability

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<f64>

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for MultivariateLogNormal

type Support = LinearSpace<Reals>

fn support(&self) -> LinearSpace<Reals>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<f64>

fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for MultivariateNormal

type Support = LinearSpace<Reals>

fn support(&self) -> LinearSpace<Reals>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<f64>

fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Multinomial

type Support = LinearSpace<Ordinal>

fn support(&self) -> LinearSpace<Ordinal>

fn cdf(&self, _: Vector<usize>) -> Probability

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> Vector<usize>

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Arcsine

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Beta

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for BetaPrime

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Cauchy

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Chi

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for ChiSq

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Cosine

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Erlang

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Exponential

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for FDist

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Frechet

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Gamma

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for GeneralisedExtremeValue

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for GeneralisedPareto

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Gumbel

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for InvGamma

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for InvNormal

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Laplace

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Levy

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for LogNormal

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Logistic

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Normal

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Pareto

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Rayleigh

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for StudentT

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Triangular

type Support = Interval

fn support(&self) -> Interval

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Weibull

type Support = PositiveReals

fn support(&self) -> PositiveReals

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Bernoulli

type Support = Binary

fn support(&self) -> Binary

fn cdf(&self, k: bool) -> Probability

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> bool

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for BetaBinomial

type Support = Ordinal

fn support(&self) -> Ordinal

fn cdf(&self, k: usize) -> Probability

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> usize

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Binomial

type Support = Ordinal

fn support(&self) -> Ordinal

fn cdf(&self, k: usize) -> Probability

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Categorical

type Support = Ordinal

fn support(&self) -> Ordinal

fn cdf(&self, _: usize) -> Probability

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> usize

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Geometric

type Support = NonNegativeIntegers

fn support(&self) -> NonNegativeIntegers

fn cdf(&self, k: u64) -> Probability

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> u64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Poisson

type Support = Naturals

fn support(&self) -> Naturals

fn cdf(&self, _: u64) -> Probability

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Degenerate<f64>

type Support = Reals

fn support(&self) -> Reals

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

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Degenerate<i64>

type Support = Integers

fn support(&self) -> Integers

fn cdf(&self, x: i64) -> Probability

fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> i64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Uniform<f64>

type Support = RealInterval

fn support(&self) -> RealInterval

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl Distribution for Uniform<i64>

type Support = DiscreteInterval

fn support(&self) -> DiscreteInterval

fn cdf(&self, k: i64) -> Probability

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

impl<C: Distribution> Distribution for Mixture<C> where
    C::Support: Clone, 

type Support = C::Support

fn support(&self) -> Self::Support

fn cdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn sample<R: Rng + ?Sized>(
    &self,
    rng: &mut R
) -> <Self::Support as Space>::Value

fn ccdf(&self, x: <Self::Support as Space>::Value) -> Probability

fn logcdf(&self, x: <Self::Support as Space>::Value) -> f64

fn logccdf(&self, x: <Self::Support as Space>::Value) -> f64

fn cdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn ccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<Probability>

fn logcdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn logccdf_batch(
    &self,
    xs: Vector<<Self::Support as Space>::Value>
) -> Vector<f64>

fn sample_n<D, Sh, R: ?Sized>(
    &self,
    rng: &mut R,
    shape: Sh
) -> Array<<Self::Support as Space>::Value, D> where
    D: Dimension,
    Sh: ShapeBuilder<Dim = D>,
    R: Rng, 

Important traits for Sampler<D, R>

impl<D, R> Iterator for Sampler<D, R> where
    D: Distribution,
    R: Rng,  type Item = <D::Support as Space>::Value;

fn sample_iter<R>(self, rng: R) -> Sampler<Self, R> where
    Self: Sized,
    R: Rng, 

Loading content...