Enum MarginRule 

pub enum MarginRule {
    BudgetRatio {
        dimension_index: usize,
        budget: f64,
    },
    RangeBound {
        dimension_index: usize,
        min: f64,
        max: f64,
    },
    PatternMatch {
        dimension_index: usize,
        approved_values: Vec<f64>,
        tolerance: f64,
        fallback_margin: f64,
    },
    WeightedSum {
        weights: Vec<(usize, f64)>,
        offset: f64,
    },
    Constant {
        margin: f64,
    },
}

How to compute the margin from a state vector.

Variants

BudgetRatio

Margin = value / budget. Produces 1.0 when value == 0, 0.0 when value >= budget. dimension_index selects which state dimension to read.

Fields

dimension_index: usize

budget: f64

RangeBound

Margin = how far value is from the [min, max] boundary, normalized to [0, 1]. Inside range → margin based on distance to nearest edge.

Fields

dimension_index: usize

min: f64

max: f64

PatternMatch

Margin = 1.0 if value matches pattern, else fallback. Useful for categorical checks (e.g., “is this in an approved list?”).

Fields

dimension_index: usize

approved_values: Vec<f64>

Values that produce margin = 1.0

tolerance: f64

Tolerance for floating-point comparison

fallback_margin: f64

Margin when value is not approved

WeightedSum

Margin computed from a simple arithmetic expression over state dimensions. Supports: weighted sum clamped to [0, 1].

Fields

weights: Vec<(usize, f64)>

(dimension_index, weight) pairs

offset: f64

Offset added after weighted sum

Constant

Constant margin — useful for testing or placeholder channels.

Fields

margin: f64

Trait Implementations

impl Clone for MarginRule

fn clone(&self) -> MarginRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MarginRule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MarginRule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MarginRule

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

where __S: Serializer,

Serialize this value into the given Serde serializer.