Enum IndexFn 

pub enum IndexFn {
    Lattice {
        axis_sizes: Vec<u64>,
    },
    Lockstep {
        length: u64,
    },
    Modular {
        axis_sizes: Vec<u64>,
    },
    Concatenation {
        segment_sizes: Vec<u64>,
    },
    Continuous {
        intervals: Vec<Interval>,
        measure: ProductMeasure,
    },
    Hybrid {
        discrete_axes: Vec<u64>,
        continuous_axes: Vec<Interval>,
        measure: ProductMeasure,
    },
}

Closed-form addressing schemes — spec §10.7.1.

Six variants. Each describes the bijection from a 0..cardinality index range to the node’s tuple shape. Continuous and Hybrid carry the cardinality’s interval+measure descriptors directly so the R2 push-down rules (Phase 6) can dispatch on them without recomputing.

Variants

Lattice

Discrete cartesian. axis_sizes[i] is the i-th axis’s element count. Multi-index (i₀, i₁, …) maps to the per-axis tuple at those positions.

Fields

axis_sizes: Vec<u64>

Element count per axis.

Lockstep

Zip Strict / Truncate. One index i ∈ 0..length maps to the per-child tuple at position i.

Fields

length: u64

The common length.

Modular

Zip Cycle. Modular addressing — index i maps to each child at i mod child.cardinality. At least one child must be bounded (the cycling target).

Fields

axis_sizes: Vec<u64>

Element count per child.

Concatenation

Union of index-addressable children. Index i ∈ 0..Σsegment_sizes maps to segment k where k is the smallest such that Σ₀^k segment_sizes > i, position i - Σ₀^{k-1} segment_sizes within that segment.

Fields

segment_sizes: Vec<u64>

Element count per segment, in order.

Continuous

Continuous K-D box. Strategy push-down rules (Halton / Sobol / Lhs / Extrema on Continuous) draw from this directly; the discrete-to-continuous mapping is strategy-specific.

Fields

intervals: Vec<Interval>

The interval of each axis.

measure: ProductMeasure

The measure drawn from.

Hybrid

Mixed discrete × continuous cartesian. Discrete axes get integer indexing; continuous axes get measure-weighted sampling. Strategy push-down dispatches per-axis.

Fields

discrete_axes: Vec<u64>

Element count per discrete axis.

continuous_axes: Vec<Interval>

The interval of each continuous axis.

measure: ProductMeasure

The measure over the continuous axes.

Implementations

impl IndexFn

pub fn has_continuous_axis(&self) -> bool

true if this index function carries any continuous axis. Used by per-strategy V4 checks to reject strategies that don’t accept continuous inputs.

pub fn is_multi_axis_lattice(&self) -> bool

true if this index function is a multi-axis Lattice (discrete cartesian with ≥2 axes). Required by lattice-geometric strategies (Extrema / Shells / Diagonal / Antidiagonal) for non-degenerate behavior.

Trait Implementations

impl Clone for IndexFn

fn clone(&self) -> IndexFn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexFn

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IndexFn

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IndexFn

fn eq(&self, other: &IndexFn) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for IndexFn

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IndexFn