Struct Zipf

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

The Zipf (Zipfian) distribution Zipf(n, s).

The samples follow Zipf’s law: The frequency of each sample from a finite set of size n is inversely proportional to a power of its frequency rank (with exponent s).

For large n, this converges to the Zeta distribution.

For s = 0, this becomes a uniform distribution.

Plot

The following plot illustrates the Zipf distribution for n = 10 and various values of s.

Example

use rand::prelude::*;
use rand_distr::Zipf;

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

Integer vs FP return type

This implementation uses floating-point (FP) logic internally. It may be expected that the samples are no greater than n, thus it is reasonable to cast generated samples to any integer type which can also represent n (e.g. distr.sample(&mut rng) as u64).

Implementation details

Implemented via rejection sampling, due to Jason Crease1.

Implementations

impl<F> Zipf<F>

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

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

Construct a new Zipf distribution for a set with n elements and a frequency rank exponent s.

The parameter n is typically integral, however we use type

F: [Float]

in order to permit very large values

and since our implementation requires a floating-point type.

Trait Implementations

impl<F> Clone for Zipf<F>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Debug for Zipf<F>

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

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

Formats the value using the given formatter.

impl<F> Distribution<F> for Zipf<F>

where F: Float, StandardUniform: 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 Zipf<F>

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

fn eq(&self, other: &Zipf<F>) -> bool

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

const 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 Zipf<F>

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

impl<F> StructuralPartialEq for Zipf<F>

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