Enum StrategyName 

pub enum StrategyName {
    Lex,
    ReverseLex,
    Shuffle,
    Halton,
    Sobol,
    Lhs,
    Extrema,
    Shells,
    Diagonal,
    Antidiagonal,
}

Named ordering strategies per spec §3.6 (plus Shuffle).

Each strategy declares its accepted input IndexFn shape per the spec §3.6 strategy table. V4 (§5) enforces the per-strategy input-shape contract; R2 (§10.2) implements the per-strategy push-down rule.

Variants

Lex

Natural enumeration order — pass-through. Accepts any input including None. The only strategy whose materialization is Streaming (§10.2 R1).

ReverseLex

Reverse the input’s index range. Accepts any non-None discrete IndexFn; rejected over continuous.

Shuffle

Random permutation. PRNG seed captured at materialization. Accepts any non-None IndexFn including continuous.

Halton

Halton low-discrepancy sequence. K-D over Lattice; 1-D over single-axis index spaces; native to Continuous (canonical use case).

Sobol

Sobol low-discrepancy sequence. Same shape as Halton.

Lhs

Latin Hypercube stratified sampling. K-D over Lattice; degenerate (= Shuffle) over 1-D; native to Continuous.

Extrema

K-D lattice corners (2^N). Sorted by distance metric; emit top k. Discrete Lattice with N≥2 axes or Continuous box; degenerate over 1-D.

Shells

Concentric shell partitioning. Discrete only; rejected over continuous (ill-defined without discretization).

Diagonal

Index-sum-ascending walk. Discrete Lattice with N≥2 axes; rejected over continuous.

Antidiagonal

Index-sum-descending walk. Discrete Lattice with N≥2 axes; rejected over continuous.

Implementations

impl StrategyName

pub fn is_streaming(self) -> bool

true if the strategy is Lex — the only streaming strategy (§3.6, §6.2, §10.2 R1).

pub fn is_index_sampling(self) -> bool

true if the strategy operates over a 1-D index space without geometric interpretation. Index-sampling strategies (Halton/Sobol/Lhs/Shuffle/ReverseLex) work over any non-None IndexFn; lattice-geometric strategies (Extrema/Shells/Diagonal/Antidiagonal) require Lattice with ≥2 axes.

pub fn is_lattice_geometric(self) -> bool

true if the strategy is a lattice-geometric measure (corners, shells, diagonals). These require a multi-axis Lattice and reject continuous inputs.

pub fn as_str(self) -> &'static str

Human-readable strategy name used in surface syntax (e.g., order halton/n).

Trait Implementations

impl Clone for StrategyName

fn clone(&self) -> StrategyName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StrategyName

impl Debug for StrategyName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StrategyName

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StrategyName

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

Formats the value using the given formatter.

impl Eq for StrategyName

impl Hash for StrategyName

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StrategyName

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for StrategyName

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 StrategyName