Struct MclmcSettings 

pub struct MclmcSettings<A: Debug + Copy + Default + Serialize> {

    pub step_size: f64,
    pub momentum_decoherence_length: f64,
    pub num_tune: u64,
    pub num_draws: u64,
    pub num_chains: usize,
    pub seed: u64,
    pub max_energy_error: f64,
    pub store_unconstrained: bool,
    pub store_gradient: bool,
    pub store_transformed: bool,
    pub store_divergences: bool,
    pub adapt_options: A,
    pub subsample_frequency: f64,
    pub dynamic_step_size: bool,
    pub trajectory_kind: MclmcTrajectoryKind,
    pub trajectory_switch_fraction: f64,
}

Settings for the unadjusted Microcanonical Langevin Monte Carlo (MCLMC) sampler.

⚠️ Experimental — use with caution: The MCLMC sampler and all of its variants are highly experimental. They have not been thoroughly validated and may not return correct posteriors. The API, defaults, and adaptation behaviour are all subject to breaking changes at any time. Do not use these samplers in production or for results you rely on.

Step size ε and momentum decoherence length L are constants — no adaptation of those is performed yet. The geometry is adapted during warmup using the sampler-specific adaptation strategy, while the step size remains fixed.

Use the type aliases DiagMclmcSettings, LowRankMclmcSettings, and FlowMclmcSettings for concrete configurations.

Fields

step_size: f64

Step size ε for the ESH leapfrog integrator.

momentum_decoherence_length: f64

Momentum decoherence length L (controls partial momentum refresh rate). Set to f64::INFINITY to disable momentum refresh entirely.

num_tune: u64

Number of warmup draws.

num_draws: u64

Number of sampling draws after warmup.

num_chains: usize

Number of parallel chains.

seed: u64

RNG seed.

max_energy_error: f64

Maximum energy error before a step is flagged as a divergence.

store_unconstrained: bool

Store each unconstrained parameter vector in the sampler stats.

store_gradient: bool

Store the gradient in the sampler stats.

store_transformed: bool

Store the transformed gradient and value in the sampler stats

store_divergences: bool

Store detailed information about each divergence in the sampler stats

adapt_options: A

Geometry adaptation options (step-size fields are ignored for Euclidean settings).

subsample_frequency: f64

Number of leapfrog steps per draw as a fraction of L / ε.

The number of leapfrog steps between collector calls is: round(subsample_frequency * L / ε).max(1)

• 1.0 (default) — one sample per full trajectory (at the final step).
• 0.0 — every leapfrog step.
• Values in between space samples as a fraction of the decoherence length, so the interval scales naturally when L or ε changes.

dynamic_step_size: bool

When true, use the tree-structured step size retry on divergence: halve the step size factor and try 2 steps before doubling back. log_weight will include log(step_size) to correct for the varying sampling density. When false, divergences are recorded immediately without any retry and log_weight = -energy_change.

trajectory_kind: MclmcTrajectoryKind

Selects which leapfrog integrator and partial-momentum-refresh style to use. See MclmcTrajectoryKind for the available options. Default: MclmcTrajectoryKind::Microcanonical (original MCLMC).

trajectory_switch_fraction: f64

Fraction of num_tune draws at which the trajectory is switched from Euclidean to Microcanonical when trajectory_kind == MclmcTrajectoryKind::EuclideanEarlyThenMicrocanonical. Ignored for other trajectory kinds. Default: 0.3.

Trait Implementations

impl<A: Clone + Debug + Copy + Default + Serialize> Clone for MclmcSettings<A>

fn clone(&self) -> MclmcSettings<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Debug + Copy + Default + Serialize> Debug for MclmcSettings<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for MclmcSettings<A>

where A: Deserialize<'de> + Debug + Copy + Default + Serialize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Serialize for MclmcSettings<A>

where A: Serialize + Debug + Copy + Default + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Copy + Debug + Copy + Default + Serialize> Copy for MclmcSettings<A>