Struct Zeta 

pub struct Zeta<F>
where
    F: Float,
    StandardUniform: Distribution<F>,
    OpenClosed01: Distribution<F>,
{ /* private fields */ }

The Zeta distribution Zeta(s).

The Zeta distribution is a discrete probability distribution with parameter s. It is a special case of the Zipf distribution with n = ∞. It is also known as the discrete Pareto, Riemann-Zeta, Zipf, or Zipf–Estoup distribution.

Density function

f(k) = k^(-s) / ζ(s) for k >= 1, where ζ is the Riemann zeta function.

Plot

The following plot illustrates the zeta distribution for various values of s.

Example

use rand::prelude::*;
use rand_distr::Zeta;

let val: f64 = rand::rng().sample(Zeta::new(1.5).unwrap());
println!("{}", val);

Integer vs FP return type

This implementation uses floating-point (FP) logic internally, which can potentially generate very large samples (exceeding e.g. u64::MAX).

It is safe to cast such results to an integer type using as (e.g. distr.sample(&mut rng) as u64), since such casts are saturating (e.g. 2f64.powi(64) as u64 == u64::MAX). It is up to the user to determine whether this potential loss of accuracy is acceptable (this determination may depend on the distribution’s parameters).

Notes

The zeta distribution has no upper limit. Sampled values may be infinite. In particular, a value of infinity might be returned for the following reasons:

1. it is the best representation in the type F of the actual sample.
2. to prevent infinite loops for very small s.

Implementation details

We are using the algorithm from Non-Uniform Random Variate Generation, Section 6.1, page 551.

Implementations

impl<F> Zeta<F>

where F: Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

pub fn new(s: F) -> Result<Zeta<F>, Error>

Construct a new Zeta distribution with given s parameter.

Trait Implementations

impl<F> Clone for Zeta<F>

where F: Clone + Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

fn clone(&self) -> Zeta<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Debug for Zeta<F>

where F: Debug + Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

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

Formats the value using the given formatter.

impl<F> Distribution<F> for Zeta<F>

where F: Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

fn sample<R>(&self, rng: &mut R) -> F

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<F> PartialEq for Zeta<F>

where F: PartialEq + Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

fn eq(&self, other: &Zeta<F>) -> 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<F> Copy for Zeta<F>

where F: Copy + Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,

impl<F> StructuralPartialEq for Zeta<F>

where F: Float, StandardUniform: Distribution<F>, OpenClosed01: Distribution<F>,