Struct NormalOptimizationInput 

pub struct NormalOptimizationInput {
    pub budget: f64,
    pub belief_mean: f64,
    pub belief_sigma: f64,
    pub market_mean: f64,
    pub market_sigma: f64,
    pub effective_k: f64,
    pub payout_amplifier: f64,
    pub constraints: OptimizerConstraints,
}

Inputs to optimize_normal_trade.

Fields

budget: f64

Trader’s budget in collateral tokens.

belief_mean: f64

Trader’s belief mean.

belief_sigma: f64

Trader’s belief σ (from the UI’s confidence selector).

market_mean: f64

Current market mean.

market_sigma: f64

Current market σ.

effective_k: f64

AMM effective_k (post LP scaling).

payout_amplifier: f64

Payout amplifier (default 1.0).

constraints: OptimizerConstraints

Policy bounds.

Implementations

impl NormalOptimizationInput

pub fn new( budget: f64, belief_mean: f64, belief_sigma: f64, market_mean: f64, market_sigma: f64, effective_k: f64, ) -> Self

Convenience constructor with sane defaults (amplifier=1, default constraints).

Examples found in repository

examples/sigma_arb_probe.rs (lines 31-33)

fn main() {
    let cases: &[(&str, f64, f64, f64, f64, f64, f64)] = &[
        // (label, mu_b, sigma_b, mu_m, sigma_m, k_eff, budget)
        ("live-CPI-2026-05-14",        4.3274, 0.2143, 4.2900, 0.3500, 75.07, 50.0),
        ("μ-only arb HUGE budget",     4.5000, 0.3500, 4.2900, 0.3500, 75.07, 1e9),
        ("σ-only HUGE budget",         4.2900, 0.2143, 4.2900, 0.3500, 75.07, 1e9),
        ("classic README scenario",    2.4700, 0.1581, 2.1000, 0.2000, 50.00, 50.0),
        ("scenario w/ low k",          4.5000, 0.3500, 4.2900, 0.3500,  1.00, 50.0),
        ("CPI shape unequal-σ",        4.3274, 0.2143, 2.1000, 0.3500, 75.07, 50.0),
        ("CPI σ + low-μ market",       4.3274, 0.2143, 0.1000, 0.3500, 75.07, 50.0),
        ("README+CPI-μ μ-only",        2.4700, 0.2000, 2.1000, 0.2000, 50.00, 50.0),
    ];

    println!(
        "{:<26} {:>9} {:>9} {:>9} {:>9} {:>11} {:>10} {:>9} {:>9} {:>9} {:>9}",
        "case", "μ_b", "σ_b", "μ_m", "σ_m", "k_eff", "budget", "μ_g*", "σ_g*", "coll", "EV"
    );
    println!("{}", "─".repeat(132));

    for (label, mu_b, sigma_b, mu_m, sigma_m, k, budget) in cases.iter().copied() {
        let r = optimize_normal_trade(NormalOptimizationInput::new(
            budget, mu_b, sigma_b, mu_m, sigma_m, k,
        ));
        println!(
            "{label:<26} {mu_b:>9.4} {sigma_b:>9.4} {mu_m:>9.4} {sigma_m:>9.4} {k:>11.4} \
             {budget:>10.2} {:>9.4} {:>9.4} {:>9.4} {:>9.4}",
            r.optimized_mean,
            r.optimized_sigma,
            r.collateral_required,
            r.expected_value,
        );
    }
}

Trait Implementations

impl Clone for NormalOptimizationInput

fn clone(&self) -> NormalOptimizationInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalOptimizationInput

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

Formats the value using the given formatter.

impl PartialEq for NormalOptimizationInput

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for NormalOptimizationInput

impl StructuralPartialEq for NormalOptimizationInput