Struct PolyaGamma 

pub struct PolyaGamma { /* private fields */ }

Polya-Gamma sampler.

The PolyaGamma struct enables sampling from the Polya-Gamma distribution PG(b, c) using a either a finite sum-of-gammas approximation or exact sampling following Devroye (2009).

Example

use polya_gamma::PolyaGamma;
let pg = PolyaGamma::new(1.0);
let sample = pg.draw(&mut StdRng::seed_from_u64(0), 1.0);

Implementations

impl PolyaGamma

pub fn new(shape: f64) -> Self

Create a new PolyaGamma sampler with a shape parameter.

Note: values of the tilt parameter c are passed to the draw and draw_vec methods.

Arguments

• shape - Shape parameter b for PG(b,c)

Panics

Panics if shape is not positive.

pub fn set_shape(&mut self, shape: f64)

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

Draw a single Polya-Gamma random variate PG(b, c).

This function generates samples from the Polya-Gamma distribution with shape parameter b and tilt parameter c. It uses different sampling strategies based on the value of b:

• For b = 1 or 2: Uses Devroye’s exact sampling algorithm
• For integer b > 2: Sums b independent PG(1, c) variates
• For non-integer b: Uses a gamma-Poisson mixture representation

Arguments

• b - Shape parameter (must be > 0)
• c - Tilt parameter (real-valued)
• rng - Random number generator

Returns

A random variate from PG(b, c)

Panics

Panics if b is not positive.

Example

let mut pg = PolyaGamma::new(1.0);
let mut rng = rand::thread_rng();

// Sample from PG(1, 0.5)
let sample = pg.draw(&mut rng, 0.5);

// Sample from PG(3.5, -1.2)
pg.set_shape(3.5);
let sample2 = pg.draw(&mut rng, -1.2);

pub fn draw_vec<R: Rng + ?Sized>(&self, rng: &mut R, c: &[f64]) -> Vec<f64>

Draw multiple Polya-Gamma random variates PG(b, c).

Arguments

• rng - Mutable reference to a random number generator
• c - Tilt parameters (real-valued)

Returns

A vector of random variates from PG(b, c)

Panics

Panics if b is not positive.

Example

let mut pg = PolyaGamma::new(1.0);
let mut rng = rand::thread_rng();

// Draw 100 samples from PG(1, 0.5)
let samples = pg.draw_vec(&mut rng, &[0.5; 100]);
println!("Drew {} samples from PG(1, 0.5)", samples.len());

pub fn draw_vec_par_deterministic<R: SeedableRng + Rng>( &self, rng: &mut R, c: &[f64], ) -> Vec<f64>

Draw multiple Polya-Gamma random variates PG(b, c) in parallel.

The initial seed is drawn from the provided rng. Each thread is then given a unique seed based on the initial seed. This ensures that the samples are deterministic across runs.

Note that this function is slightly slower than draw_vec_par, which should be preferred in production workloads.

Arguments

• rng - Mutable reference to a random number generator
• c - Tilt parameters (real-valued)

Returns

A vector of random variates from PG(b, c)

Panics

Panics if b is not positive.

Example

let pg = PolyaGamma::new(1.0);
let mut rng = StdRng::seed_from_u64(0);

// Draw 100 samples from PG(1, 0.5)
let samples = pg.draw_vec_par_deterministic(&mut rng, &[0.5; 100]);
println!("Drew {} samples from PG(1, 0.5)", samples.len());

pub fn draw_vec_par(&self, c: &[f64]) -> Vec<f64>

Draw multiple Polya-Gamma random variates PG(b, c) in parallel.

Arguments

• c - Tilt parameters (real-valued)

Returns

A vector of random variates from PG(b, c)

Example

let pg = PolyaGamma::new(1.0);

// Draw 100 samples from PG(1, 0.5)
let samples = pg.draw_vec_par(&[0.5; 100]);
println!("Drew {} samples from PG(1, 0.5)", samples.len());

Trait Implementations

impl Clone for PolyaGamma

fn clone(&self) -> PolyaGamma

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PolyaGamma

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

Formats the value using the given formatter.