Struct RefineParams 

pub struct RefineParams {
    pub num_gibbs: usize,
    pub num_greedy: usize,
    pub feature_weighting: FeatureWeighting,
    pub seed: u64,
    pub gibbs_stagnation: f64,
    pub profile_source: ProfileSource,
    pub parallel: bool,
    pub prior_count: f32,
    pub min_gain_z: f32,
    pub size_floor: f32,
    pub size_cap: f32,
}

Parameters controlling the refinement pass.

Fields

num_gibbs: usize

Gibbs sweeps per level (0 disables Gibbs; greedy still runs).

num_greedy: usize

Greedy sweeps per level (early-exits on zero moves).

feature_weighting: FeatureWeighting

Per-feature weighting scheme (only meaningful for Raw profile source).

seed: u64

Seed for Gibbs RNG.

gibbs_stagnation: f64

Gibbs stagnation threshold (fraction of entities moving per sweep). Breaks early when three consecutive sweeps are below this bound. 0.0 disables early exit.

profile_source: ProfileSource

Feature source. Defaults to Raw.

parallel: bool

Jacobi-style parallel sweeps (default true).

When true, every entity proposes its move against a frozen pre-sweep snapshot of the sufficient stats (rayon par_iter); proposals are then applied sequentially with the move guard. Per-entity RNG seeds are derived from (sweep_seed, entity_idx), so the result is deterministic given seed and independent of thread count (per rand release — SmallRng’s stream is not guaranteed stable across rand versions).

When false, runs the classic Gauss–Seidel loop: each entity scores against the live stats (updated by every accepted move so far in the sweep), single-threaded. The statistics are still built on the rayon pool; the labels are the same on any number of threads.

Jacobi is biased — within a sweep, entities can’t see each other’s moves — but converges fine for the multilevel DC-Poisson use case and is roughly P× faster on large pb-sample counts.

prior_count: f32

Pseudo-count c added to every block total before its log (default 0.5; values under LOG_EPS are raised to it). A block total is read against what a block of the pooled profile and the same mass would show, so a feature a block has not seen costs little where none was expected, and an empty block scores as the pooled profile. A larger c holds block profiles closer to the pooled one where counts are few. See DcPoissonStats.

min_gain_z: f32

Standard deviations of block-estimate noise by which a destination has to beat the current block (default 1.5; 0 asks for any positive gain). The noise is larger for smaller blocks, so this is what keeps a small block from losing, or taking in, members on the strength of its own sampling error. See DcPoissonStats.

size_floor: f32

Fraction of min(starting size, mean block size) below which no block is taken, rounded up (default 0.9); any positive value also keeps the last member of every block. 0 lets blocks shrink and empty.

The refinement is asked to make a given partition purer, not to choose the number of blocks: by the likelihood alone, the members of a mixed block all do better elsewhere, and the block dissolves.

A block at its floor still exchanges members: a move the limits refuse is applied together with a move the other way between the same two blocks.

Both limits are taken from the sizes a call starts with, so they bound one call. Refining the output again starts from the new sizes and may take a block a step further: at the default, a tenth of its members while it has ten or more, and none below ten unless it is larger than the mean. No positive floor empties a block, over any number of calls.

size_cap: f32

Multiple of max(starting size, mean block size) above which no block is taken, rounded up (default 1.25). 0 lifts the limit.

Trait Implementations

impl Clone for RefineParams

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RefineParams

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

Formats the value using the given formatter.

impl Default for RefineParams

fn default() -> Self

Returns the “default value” for a type.