Function run_walk_forward

crates/openquant/src/backtesting_engine.rs:184–248

(
    data: &BacktestData,
    run: &BacktestRunConfig,
    config: &WalkForwardConfig,
    mut evaluator: E,
)

}

pub fn run_walk_forward<E>(
    data: &BacktestData,
    run: &BacktestRunConfig,
    config: &WalkForwardConfig,
    mut evaluator: E,
) -> Result<WalkForwardResult, String>
where
    E: FnMut(&SplitDefinition) -> Result<Vec<f64>, String>,
{
    data.validate()?;
    run.validate(BacktestMode::WalkForward)?;
    validate_embargo(config.pct_embargo)?;
    if config.min_train_size == 0 {
        return Err("min_train_size must be > 0".to_string());
    }
    if config.test_size == 0 {
        return Err("test_size must be > 0".to_string());
    }
    if config.step_size == 0 {
        return Err("step_size must be > 0".to_string());
    }

    let n_samples = data.returns.len();
    let mut split_defs = Vec::new();
    let mut start = config.min_train_size;
    let mut split_id = 0;

    while start < n_samples {
        let stop = (start + config.test_size).min(n_samples);
        let test_indices: Vec<usize> = (start..stop).collect();
        if test_indices.is_empty() {
            break;
        }
        let initial_train: Vec<usize> = (0..start).collect();
        let (train_indices, purged_count, embargo_count) = apply_purge_and_embargo(
            &initial_train,
            &test_indices,
            &data.label_spans,
            config.pct_embargo,
            n_samples,
        );
        if train_indices.is_empty() {
            return Err("walk-forward produced an empty train split".to_string());
        }
        split_defs.push(SplitDefinition {
            split_id,
            train_indices,
            test_indices,
            test_groups: vec![split_id],
            purged_count,
            embargo_count,
        });
        split_id += 1;
        start += config.step_size;
    }

    if split_defs.is_empty() {
        return Err("walk-forward produced no splits".to_string());