Money Flow Index

Optimization Output Example

Example output from running the optimization code above on a year of S&P data.

Best Money Flow Index parameters found:
period = 4
oversold threshold = 38
overbought threshold = 67
Rating: 0.021183800623052952
Best Indicator values: [74.44742348213569, 66.95676847723158, 100.0, ... ]

Analysis

The optimized Money Flow Index parameters (period=4, oversold=38, overbought=67) generated significantly more trading signals compared to the default settings. The default MFI parameters (period=14, oversold=20, overbought=80) produced no trades at all during the simulation period, resulting in $0.00 profit/loss.

In contrast, the optimized parameters identified numerous overbought and oversold conditions, enabling both long and short positions throughout the trading period. The strategy invested 20% of remaining capital on each trade, opening long positions when MFI fell below 38 and short positions when it rose above 67. This more sensitive configuration yielded a total profit of $23.97 (2.4% return), demonstrating that the tighter thresholds and shorter period effectively captured short-term momentum shifts in the market.

Optimized Trading Simulation

Default Trading Simulation

Trading Simulation Code

For those who want to run their own simulation to compare results.

use centaur_technical_indicators::momentum_indicators::bulk::money_flow_index;

fn simulate_trading(best_indicator: &[f64], best_period: usize, close: &[f64], best_oversold: usize, best_overbought: usize) {
    println!("\n--- Trading Simulation ---");

    let initial_capital = 1000.0;
    let mut capital = initial_capital;
    let investment_pct = 0.20;

    struct Position {
        entry_price: f64,
        shares: f64,
    }

    let mut open_long: Option<Position> = None;
    let mut open_short: Option<Position> = None;

    // Print table header
    println!("{:<5} | {:<19} | {:<10} | {:<10} | {:<12} | {:<15} | {:<10}",
             "Day", "Event", "MFI", "Price", "Shares", "Capital", "P/L");
    println!("{}", "-".repeat(95));

    for i in 0..best_indicator.len() {
        let price_index = i + best_period + 1;
        if price_index >= close.len() { break; }

        let mfi_val = best_indicator[i];
        let current_price = close[price_index];
        let day = price_index;

        // --- Handle Long Position ---
        if let Some(long_pos) = open_long.take() {
            if mfi_val > best_overbought as f64 {
                let sale_value = long_pos.shares * current_price;
                let profit = sale_value - (long_pos.shares * long_pos.entry_price);
                capital += sale_value;
                println!("{:<5} | {:<19} | {:<10.2} | ${:<9.2} | {:<12.4} | ${:<14.2} | ${:<9.2}",
                         day, "Sell (Close Long)", mfi_val, current_price, long_pos.shares, capital, profit);
            } else {
                open_long = Some(long_pos); // Put it back if not selling
            }
        } else if mfi_val < best_oversold as f64 && open_short.is_none() { // Don't buy if short is open
            let investment = capital * investment_pct;
            let shares_bought = investment / current_price;
            open_long = Some(Position { entry_price: current_price, shares: shares_bought });
            capital -= investment;
            println!("{:<5} | {:<19} | {:<10.2} | ${:<9.2} | {:<12.4} | ${:<14.2} | {}",
                     day, "Buy (Open Long)", mfi_val, current_price, shares_bought, capital, "-");
        }

        // --- Handle Short Position ---
        if let Some(short_pos) = open_short.take() {
            if mfi_val < best_oversold as f64 {
                let cost_to_cover = short_pos.shares * current_price;
                let profit = (short_pos.shares * short_pos.entry_price) - cost_to_cover;
                capital += profit; // Add profit to capital
                println!("{:<5} | {:<19} | {:<10.2} | ${:<9.2} | {:<12.4} | ${:<14.2} | ${:<9.2}",
                         day, "Cover (Close Short)", mfi_val, current_price, short_pos.shares, capital, profit);
            } else {
                open_short = Some(short_pos); // Put it back if not covering
            }
        } else if mfi_val > best_overbought as f64 && open_long.is_none() { // Don't short if long is open
            let short_value = capital * investment_pct;
            let shares_shorted = short_value / current_price;
            open_short = Some(Position { entry_price: current_price, shares: shares_shorted });
            // Capital doesn't change when opening a short, it's held as collateral
            println!("{:<5} | {:<19} | {:<10.2} | ${:<9.2} | {:<12.4} | ${:<14.2} | {}",
                     day, "Short (Open Short)", mfi_val, current_price, shares_shorted, capital, "-");
        }
    }

    println!("\n--- Final Results ---");
    if let Some(pos) = open_long {
        println!("Simulation ended with an OPEN LONG position:");
        println!("  - Shares: {:.4}", pos.shares);
        println!("  - Entry Price: ${:.2}", pos.entry_price);
        let last_price = close.last().unwrap_or(&0.0);
        let current_value = pos.shares * last_price;
        capital += current_value;
        println!("  - Position value at last price (${:.2}): ${:.2}", last_price, current_value);
    }
    if let Some(pos) = open_short {
        println!("Simulation ended with an OPEN SHORT position:");
        println!("  - Shares: {:.4}", pos.shares);
        println!("  - Entry Price: ${:.2}", pos.entry_price);
        let last_price = close.last().unwrap_or(&0.0);
        let cost_to_cover = pos.shares * last_price;
        let pnl = (pos.shares * pos.entry_price) - cost_to_cover;
        capital += pnl;
        println!("  - Unrealized P/L at last price (${:.2}): ${:.2}", last_price, pnl);
    }

    let final_pnl = capital - initial_capital;
    println!("\nInitial Capital: ${:.2}", initial_capital);
    println!("Final Capital:   ${:.2}", capital);
    println!("Total P/L:       ${:.2}", final_pnl);
}


fn main() {
    // Fetch data and perform optimization as shown in the optimization code above
    simulate_trading(&best_indicators, best_period, &close, best_oversold, best_overbought);

    // Compare with default parameters (typically period=14, oversold=20, overbought=80)
    println!("\n\nDefault Indicator values for comparison:");
    let default_mfi = money_flow_index(&close, &volume, 14);
    println!("{:?}", default_mfi);
    simulate_trading(&default_mfi, 14, &close, 20, 80);

}