Function generate_ou_paths

crates/openquant/src/synthetic_backtesting.rs:154–195

(
    params: OuProcessParams,
    initial_price: f64,
    n_paths: usize,
    horizon: usize,
    seed: u64,
)

}

pub fn generate_ou_paths(
    params: OuProcessParams,
    initial_price: f64,
    n_paths: usize,
    horizon: usize,
    seed: u64,
) -> Result<Vec<Vec<f64>>, String> {
    if !initial_price.is_finite() {
        return Err("initial_price must be finite".to_string());
    }
    if n_paths == 0 || horizon < 2 {
        return Err("n_paths must be > 0 and horizon must be >= 2".to_string());
    }
    if !params.phi.is_finite()
        || !params.intercept.is_finite()
        || !params.equilibrium.is_finite()
        || !params.sigma.is_finite()
    {
        return Err("O-U parameters must be finite".to_string());
    }
    if params.sigma < 0.0 {
        return Err("sigma must be non-negative".to_string());
    }

    let mut rng = StdRng::seed_from_u64(seed);
    let noise = StandardNormal;
    let mut out = Vec::with_capacity(n_paths);

    for _ in 0..n_paths {
        let mut path = Vec::with_capacity(horizon);
        path.push(initial_price);
        for _ in 1..horizon {
            let prev = path[path.len() - 1];
            let eps: f64 = noise.sample(&mut rng);
            let next = params.intercept + params.phi * prev + params.sigma * eps;
            path.push(next);
        }
        out.push(path);
    }

    Ok(out)
}

pub fn evaluate_rule_on_paths(
    paths: &[Vec<f64>],