Function build_path_distribution

crates/openquant/src/backtesting_engine.rs:648–703

(
    n_groups: usize,
    group_index_map: &[Vec<usize>],
    assignments: &[CpcvPathAssignment],
    splits: &[SplitDefinition],
    split_returns: &HashMap<usize, Vec<f64>>,
)

}

fn build_path_distribution(
    n_groups: usize,
    group_index_map: &[Vec<usize>],
    assignments: &[CpcvPathAssignment],
    splits: &[SplitDefinition],
    split_returns: &HashMap<usize, Vec<f64>>,
) -> Result<Vec<CpcvPathPerformance>, String> {
    let mut out = Vec::with_capacity(assignments.len());
    for assignment in assignments {
        if assignment.split_for_group.len() != n_groups {
            return Err("invalid path assignment length".to_string());
        }

        let mut path_returns = Vec::new();
        for (group_id, split_id) in assignment.split_for_group.iter().enumerate() {
            let split = splits
                .iter()
                .find(|s| s.split_id == *split_id)
                .ok_or_else(|| "path references unknown split".to_string())?;
            if !split.test_groups.contains(&group_id) {
                return Err("path assignment references split not containing group".to_string());
            }
            let split_path_returns = split_returns
                .get(split_id)
                .ok_or_else(|| "missing split returns for CPCV path construction".to_string())?;
            if split_path_returns.len() != split.test_indices.len() {
                return Err("split return count must match split test indices length".to_string());
            }
            let return_by_index: HashMap<usize, f64> = split
                .test_indices
                .iter()
                .copied()
                .zip(split_path_returns.iter().copied())
                .collect();

            for idx in &group_index_map[group_id] {
                if split.test_indices.contains(idx) {
                    let r = return_by_index
                        .get(idx)
                        .ok_or_else(|| "split returns missing group test index".to_string())?;
                    path_returns.push(*r);
                }
            }
        }

        let perf = summarize_returns(assignment.path_id, &path_returns)?;
        out.push(CpcvPathPerformance {
            path_id: assignment.path_id,
            sharpe: perf.sharpe,
            mean_return: perf.mean_return,
            std_return: perf.std_return,
            observations: perf.observations,
        });
    }
    Ok(out)
}