Function dfs_paths

crates/openquant/src/combinatorial_optimization.rs:420–461

(
    schema: &TradingTrajectorySchema,
    step: usize,
    trades: &mut Vec<i64>,
    inventory_path: &mut Vec<i64>,
    out: &mut Vec<TradingTrajectoryPath>,
)

}

fn dfs_paths(
    schema: &TradingTrajectorySchema,
    step: usize,
    trades: &mut Vec<i64>,
    inventory_path: &mut Vec<i64>,
    out: &mut Vec<TradingTrajectoryPath>,
) -> Result<(), CombinatorialOptimizationError> {
    if out.len() >= schema.max_paths {
        return Err(CombinatorialOptimizationError::EnumerationLimitExceeded {
            limit: schema.max_paths,
        });
    }
    if step == schema.horizon() {
        let inventory_final = *inventory_path.last().unwrap_or(&schema.initial_inventory);
        if schema.terminal_inventory.is_some_and(|required| required != inventory_final) {
            return Ok(());
        }
        out.push(TradingTrajectoryPath {
            trades: trades.clone(),
            inventory_path: inventory_path.clone(),
        });
        return Ok(());
    }

    let bounds = schema.step_trade_bounds[step];
    for trade in bounds.min_trade..=bounds.max_trade {
        let current = *inventory_path.last().unwrap_or(&schema.initial_inventory);
        let next = match current.checked_add(trade) {
            Some(v) => v,
            None => continue,
        };
        if next < schema.inventory_min || next > schema.inventory_max {
            continue;
        }
        trades.push(trade);
        inventory_path.push(next);
        dfs_paths(schema, step + 1, trades, inventory_path, out)?;
        inventory_path.pop();
        trades.pop();
    }
    Ok(())
}

fn enumerate_decisions(
    values: &[Vec<i64>],