The strength of BE system

Quoting pusztafie

Disliked

Today's result of the new EA. The day started well, in the morning it was $1000 more, by the evening it barely had a little left. {image}

Ignored

Quoting RogerCS

Disliked

{quote} Mine also keeps converging to the equilibrium point

Ignored

Quoting cfudge

Disliked

Here are the results from the original EA still running the regular method Chart 1 is Feb 2nd to Feb 13th. Chart 2 is Feb 16th to Feb 27th (today). Chart 3 is the full result from Feb 1st to Feb 27th (today). I am going to think about not running this EA anymore but changing to the new EA and trying the Regular method with a few of the new tweaks. I believe I am happy with the results of this test so far. Chris {image} {image} {image}

Ignored

Quote

Disliked

I'll be direct and honest about the results: It has potential but far from it. It's not tradeable by any means. Even if you do see any profits in your forward tests, overtime the results/PnL will converge to breakeven at best.

Quote

Disliked

Why not test other settings: Let's say I test with different input parameters, on different timeframes and different symbols. Even if I do find a profitable symbol, timeframe or input settings the strategy itself is fragile. Why? Because a robust strategy gives profit either way. It does not have to be a clean equity curve, but it needs to be profitable* and the current results suggest potential not profitability.

Quote

Disliked

Do we loose hope: NO. The strategy is unique and clearly has some periods of profitability. If we can understand why some periods are better for the EA than others, the strategy can be enhanced. For instance, in the image shown above, the equity curve had an upward trend in 5-15-2025. WHY? What caused this? Was it volatility? Was it something fundamental-related? What were the market conditions like? Answers to such questions will lead you to improve the strategy.

Quoting amvt

Disliked

Post #366 {quote} {quote}

Ignored

Quoting cfudge

Disliked

{quote} Here is a graph of the trades from Feb 2 to Feb 27 and the candles from the Daily chart from same times IMHO I can not get any correlation that would suggest any advantage from any particular day. This is what I thought this would show because my aim with all my threads/systems is to use a simple approach with limited uncomplicated indicators to try and get a reaction out of the chart that creates steady humble profit. Anyway if someone can see something promising in the graph and chart please tell what you can discern. {image} {image}

Ignored

"""
Trade Analysis with ATR Octant Distribution
============================================
 
Analyzes MT5 backtest trades and classifies them by ATR octants.
Shows which volatility levels produce the best win rates.
 
Output:
    - ATR octant distribution of trades
    - Win rate per octant
    - Average profit/loss per octant
    - Visual insights
"""
 
import pandas as pd
import numpy as np
import MetaTrader5 as mt5
from datetime import datetime, timedelta
import sys
 
# ============================================================================
# CONFIGURATION
# ============================================================================
 
TRADE_FILE = r""
SIGNALS_FILE = r""
SYMBOL = "EURAUD"
TIMEFRAME = mt5.TIMEFRAME_M30
ATR_PERIOD = 14
DISTRIBUTION_WINDOW_DAYS = 3  # 3-day high/low for ATR distribution
NUM_OCTANTS = 8
 
# ============================================================================
# STEP 1: LOAD AND PARSE TRADES FROM EXCEL
# ============================================================================
 
def load_trades_from_excel(file_path):
    """Load trades from MT5 Excel export."""
    print("="*60)
    print("LOADING TRADES FROM EXCEL")
    print("="*60)
 
    # Read Excel (first row is header)
    df = pd.read_excel(file_path)
 
    print(f"Total rows: {len(df)}")
    print(f"Columns: {df.columns.tolist()}")
    print(f"First few rows:")
    print(df.head(10)[['Time', 'Type', 'Direction', 'Profit', 'Comment']])
 
    # Filter only entry trades (Direction == 'in')
    entries = df[df['Direction'] == 'in'].copy()
 
    # Filter only exit trades (Direction == 'out')
    exits = df[df['Direction'] == 'out'].copy()
 
    print(f"\nFound {len(entries)} entries and {len(exits)} exits")
 
    # Match entries with exits
    trades = []
 
    for idx, entry in entries.iterrows():
        # Find corresponding exit (next row should be exit)
        entry_deal = entry['Deal']
 
        # Find exit with Deal number = entry_deal + 1
        exit_row = exits[exits['Deal'] == entry_deal + 1]
 
        if len(exit_row) == 0:
            continue
 
        exit_row = exit_row.iloc[0]
 
        # Parse entry time
        entry_time = pd.to_datetime(entry['Time'])
        exit_time = pd.to_datetime(exit_row['Time'])
 
        # Determine direction
        entry_type = str(entry['Type']).lower()
        if 'buy' in entry_type:
            direction = 'LONG'
        elif 'sell' in entry_type:
            direction = 'SHORT'
        else:
            continue
 
        # Get profit/loss (use actual Profit column)
        profit = exit_row['Profit']
 
        # Determine outcome
        if profit > 0:
            outcome = 'WIN'
        elif profit < 0:
            outcome = 'LOSS'
        else:
            outcome = 'BREAKEVEN'
 
        trades.append({
            'entry_time': entry_time,
            'exit_time': exit_time,
            'direction': direction,
            'profit': profit,
            'outcome': outcome,
            'entry_type': entry_type,
            'exit_comment': exit_row['Comment']
        })
 
    trades_df = pd.DataFrame(trades)
    print(f"\nParsed {len(trades_df)} complete trades")
    print(f"   - Wins: {len(trades_df[trades_df['outcome']=='WIN'])}")
    print(f"   - Losses: {len(trades_df[trades_df['outcome']=='LOSS'])}")
    print(f"   - Win Rate: {len(trades_df[trades_df['outcome']=='WIN'])/len(trades_df)*100:.1f}%")
    print(f"   - Total Profit: ${trades_df['profit'].sum():.2f}")
 
    return trades_df
 
 
# ============================================================================
# STEP 2: FETCH HISTORICAL DATA AND CALCULATE ATR
# ============================================================================
 
def calculate_atr(df, period=14):
    """Calculate ATR indicator."""
    # True Range
    df['h-l'] = df['high'] - df['low']
    df['h-pc'] = abs(df['high'] - df['close'].shift(1))
    df['l-pc'] = abs(df['low'] - df['close'].shift(1))
    df['tr'] = df[['h-l', 'h-pc', 'l-pc']].max(axis=1)
 
    # ATR (EMA of True Range)
    df['atr'] = df['tr'].ewm(alpha=1/period, min_periods=period, adjust=False).mean()
 
    return df
 
 
def get_historical_data(symbol, timeframe, start_date, end_date):
    """Fetch historical M30 data from MT5."""
    if not mt5.initialize():
        print("ERROR: MT5 initialization failed")
        return None
 
    rates = mt5.copy_rates_range(symbol, timeframe, start_date, end_date)
 
    if rates is None or len(rates) == 0:
        print(f"ERROR: No data for {symbol}")
        mt5.shutdown()
        return None
 
    df = pd.DataFrame(rates)
    df['time'] = pd.to_datetime(df['time'], unit='s')
    df = df[['time', 'open', 'high', 'low', 'close', 'tick_volume']]
 
    mt5.shutdown()
    return df
 
 
# ============================================================================
# STEP 3: MATCH TRADES WITH SIGNALS
# ============================================================================
 
def match_trades_with_signals(trades_df, symbol):
    """
    Match trades with their originating signals.
 
    Remember: Signal at T close → Trade executes at T+1 open
    So we look for signal on the day BEFORE entry.
    """
    print("\n" + "="*60)
    print("MATCHING TRADES WITH SIGNALS")
    print("="*60)
 
    try:
        # Load signals
        signals_df = pd.read_csv(SIGNALS_FILE)
        signals_df['date'] = pd.to_datetime(signals_df['date'])
 
        # Filter for this symbol
        symbol_signals = signals_df[signals_df['symbol'] == symbol].copy()
        symbol_signals.set_index('date', inplace=True)
 
        print(f"Loaded {len(symbol_signals)} signals for {symbol}")
 
        # For each trade, find the signal from the previous day
        signal_strengths = []
        signal_directions = []
 
        for idx, trade in trades_df.iterrows():
            entry_time = trade['entry_time']
            entry_date = entry_time.date()
 
            # Signal was generated the DAY BEFORE entry
            # Entry is at T+1, so signal is at T (entry_date - 1 day)
            signal_date = entry_date - timedelta(days=1)
 
            # Find signal for that date
            try:
                signal_row = symbol_signals.loc[pd.Timestamp(signal_date)]
 
                # Handle case where multiple signals on same date (shouldn't happen but just in case)
                if isinstance(signal_row, pd.DataFrame):
                    signal_row = signal_row.iloc[0]
 
                signal_strengths.append(signal_row['signal_strength'])
                signal_directions.append(signal_row['signal_direction'])
 
            except KeyError:
                # No signal found for this date
                signal_strengths.append(np.nan)
                signal_directions.append(None)
 
        trades_df['signal_strength'] = signal_strengths
        trades_df['signal_direction'] = signal_directions
 
        # Remove trades without signals
        before_count = len(trades_df)
        trades_df = trades_df.dropna(subset=['signal_strength'])
        after_count = len(trades_df)
 
        print(f"Matched {after_count} trades with signals")
        if before_count > after_count:
            print(f"   :warning: {before_count - after_count} trades had no matching signal")
 
        return trades_df
 
    except Exception as e:
        print(f":warning: Could not load signals: {e}")
        print("   Continuing without signal data...")
        trades_df['signal_strength'] = np.nan
        trades_df['signal_direction'] = None
        return trades_df
 
 
# ============================================================================
# STEP 4: ASSIGN ATR OCTANTS TO EACH TRADE
# ============================================================================
 
def assign_atr_octants(trades_df, symbol, timeframe):
    """Assign ATR octant (1-8) to each trade based on entry time."""
    print("\n" + "="*60)
    print("CALCULATING ATR OCTANTS")
    print("="*60)
 
    # Get date range from trades
    min_date = trades_df['entry_time'].min() - timedelta(days=30)  # Buffer for ATR calculation
    max_date = trades_df['entry_time'].max() + timedelta(days=1)
 
    print(f"Fetching data from {min_date.date()} to {max_date.date()}")
 
    # Fetch historical data
    hist_df = get_historical_data(symbol, timeframe, min_date, max_date)
 
    if hist_df is None:
        print("ERROR: Could not fetch historical data")
        return trades_df
 
    # Calculate ATR
    hist_df = calculate_atr(hist_df, period=ATR_PERIOD)
 
    print(f"Calculated ATR for {len(hist_df)} bars")
 
    # Create time-indexed ATR lookup
    hist_df.set_index('time', inplace=True)
 
    # For each trade, find ATR at entry and calculate octant
    octants = []
    atr_values = []
 
    distribution_bars = DISTRIBUTION_WINDOW_DAYS * 48  # M30: 48 bars/day
 
    for idx, trade in trades_df.iterrows():
        entry_time = trade['entry_time']
 
        # Find closest bar to entry time
        if entry_time not in hist_df.index:
            # Find nearest time
            time_diffs = abs(hist_df.index - entry_time)
            nearest_idx = time_diffs.argmin()
            entry_time = hist_df.index[nearest_idx]
 
        # Get ATR at entry
        try:
            entry_atr = hist_df.loc[entry_time, 'atr']
        except:
            octants.append(np.nan)
            atr_values.append(np.nan)
            continue
 
        # Get 3-day ATR distribution (highest/lowest ATR in last 144 bars)
        entry_idx = hist_df.index.get_loc(entry_time)
        start_idx = max(0, entry_idx - distribution_bars)
 
        atr_window = hist_df.iloc[start_idx:entry_idx+1]['atr']
 
        if len(atr_window) < 10:  # Not enough data
            octants.append(np.nan)
            atr_values.append(entry_atr)
            continue
 
        atr_min = atr_window.min()
        atr_max = atr_window.max()
        atr_range = atr_max - atr_min
 
        if atr_range == 0:  # No volatility
            octant = 4  # Middle octant
        else:
            # Calculate which octant (1-8)
            normalized_atr = (entry_atr - atr_min) / atr_range  # 0 to 1
            octant = min(int(normalized_atr * NUM_OCTANTS) + 1, NUM_OCTANTS)
 
        octants.append(octant)
        atr_values.append(entry_atr)
 
    trades_df['atr_octant'] = octants
    trades_df['atr_value'] = atr_values
 
    # Remove trades with no octant data
    trades_df = trades_df.dropna(subset=['atr_octant'])
 
    print(f" Assigned octants to {len(trades_df)} trades")
 
    return trades_df
 
 
# ============================================================================
# STEP 4: ANALYZE TRADES BY OCTANT
# ============================================================================
 
def analyze_by_octant(trades_df):
    """Analyze win rate and profit by ATR octant."""
    print("\n" + "="*60)
    print("ATR OCTANT ANALYSIS")
    print("="*60)
    print(f"ATR Period: {ATR_PERIOD}")
    print(f"Distribution Window: {DISTRIBUTION_WINDOW_DAYS} days ({DISTRIBUTION_WINDOW_DAYS*48} M30 bars)")
    print(f"Total Trades Analyzed: {len(trades_df)}")
    print("="*60)
 
    results = []
 
    for octant in range(1, NUM_OCTANTS + 1):
        octant_trades = trades_df[trades_df['atr_octant'] == octant]
 
        if len(octant_trades) == 0:
            continue
 
        total_trades = len(octant_trades)
        wins = len(octant_trades[octant_trades['outcome'] == 'WIN'])
        losses = len(octant_trades[octant_trades['outcome'] == 'LOSS'])
        win_rate = (wins / total_trades) * 100 if total_trades > 0 else 0
        avg_profit = octant_trades['profit'].mean()
        total_profit = octant_trades['profit'].sum()
        avg_atr = octant_trades['atr_value'].mean()
 
        results.append({
            'octant': octant,
            'total_trades': total_trades,
            'wins': wins,
            'losses': losses,
            'win_rate': win_rate,
            'avg_profit': avg_profit,
            'total_profit': total_profit,
            'avg_atr': avg_atr
        })
 
        # Print octant analysis
        volatility_label = "LOW" if octant <= 2 else ("MED" if octant <= 6 else "HIGH")
        print(f"\nOctant {octant} ({volatility_label} Volatility):")
        print(f"  Trades: {total_trades}")
        print(f"  Winners: {wins} ({win_rate:.1f}%)")
        print(f"  Losers: {losses} ({100-win_rate:.1f}%)")
        print(f"  Avg Profit: ${avg_profit:+.2f}")
        print(f"  Total Profit: ${total_profit:+.2f}")
        print(f"  Avg ATR: {avg_atr:.5f}")
 
    print("\n" + "="*60)
 
    # Summary
    results_df = pd.DataFrame(results)
 
    if len(results_df) > 0:
        best_octant = results_df.loc[results_df['win_rate'].idxmax()]
        worst_octant = results_df.loc[results_df['win_rate'].idxmin()]
 
        print("INSIGHTS:")
        print(f"  Best Octant: {int(best_octant['octant'])} (Win Rate: {best_octant['win_rate']:.1f}%)")
        print(f"  Worst Octant: {int(worst_octant['octant'])} (Win Rate: {worst_octant['win_rate']:.1f}%)")
 
        low_vol_trades = trades_df[trades_df['atr_octant'] <= 2]
        high_vol_trades = trades_df[trades_df['atr_octant'] >= 7]
 
        if len(low_vol_trades) > 0:
            low_vol_wr = (len(low_vol_trades[low_vol_trades['outcome']=='WIN']) / len(low_vol_trades)) * 100
            print(f"  Low Volatility (Octants 1-2): {low_vol_wr:.1f}% win rate")
 
        if len(high_vol_trades) > 0:
            high_vol_wr = (len(high_vol_trades[high_vol_trades['outcome']=='WIN']) / len(high_vol_trades)) * 100
            print(f"  High Volatility (Octants 7-8): {high_vol_wr:.1f}% win rate")
 
    print("="*60)
 
    return results_df
 
 
# ============================================================================
# STEP 5: ANALYZE TRADES BY SIGNAL STRENGTH
# ============================================================================
 
def analyze_by_signal_strength(trades_df):
    """Analyze win rate and profit by signal strength."""
    print("\n" + "="*60)
    print("SIGNAL STRENGTH ANALYSIS")
    print("="*60)
 
    # Check if signal_strength exists
    if 'signal_strength' not in trades_df.columns or trades_df['signal_strength'].isna().all():
        print(":warning: No signal strength data available. Skipping analysis.")
        return None
 
    print(f"Total Trades with Signals: {len(trades_df)}")
 
    # Get signal strength stats
    sig_min = trades_df['signal_strength'].min()
    sig_max = trades_df['signal_strength'].max()
    sig_mean = trades_df['signal_strength'].mean()
    sig_median = trades_df['signal_strength'].median()
 
    print(f"Signal Strength Range: {sig_min:.4f} to {sig_max:.4f}")
    print(f"Mean: {sig_mean:.4f} | Median: {sig_median:.4f}")
    print("="*60)
 
    # Create signal strength bins
    # Use absolute value for strength (both LONG and SHORT signals)
    trades_df['abs_signal_strength'] = trades_df['signal_strength'].abs()
 
    # Define bins based on absolute signal strength
    bins = [0, 0.05, 0.10, 0.15, 0.20, 0.30, 1.0]
    labels = ['0.00-0.05', '0.05-0.10', '0.10-0.15', '0.15-0.20', '0.20-0.30', '>0.30']
 
    trades_df['signal_strength_bin'] = pd.cut(trades_df['abs_signal_strength'], bins=bins, labels=labels)
 
    results = []
 
    for bin_label in labels:
        bin_trades = trades_df[trades_df['signal_strength_bin'] == bin_label]
 
        if len(bin_trades) == 0:
            continue
 
        total_trades = len(bin_trades)
        wins = len(bin_trades[bin_trades['outcome'] == 'WIN'])
        losses = len(bin_trades[bin_trades['outcome'] == 'LOSS'])
        win_rate = (wins / total_trades) * 100 if total_trades > 0 else 0
        avg_profit = bin_trades['profit'].mean()
        total_profit = bin_trades['profit'].sum()
        avg_signal_strength = bin_trades['abs_signal_strength'].mean()
 
        results.append({
            'strength_bin': bin_label,
            'total_trades': total_trades,
            'wins': wins,
            'losses': losses,
            'win_rate': win_rate,
            'avg_profit': avg_profit,
            'total_profit': total_profit,
            'avg_abs_strength': avg_signal_strength
        })
 
        # Print bin analysis
        print(f"\nSignal Strength: {bin_label}")
        print(f"  Trades: {total_trades} ({100*total_trades/len(trades_df):.1f}% of total)")
        print(f"  Winners: {wins} ({win_rate:.1f}%)")
        print(f"  Losers: {losses} ({100-win_rate:.1f}%)")
        print(f"  Avg Profit: ${avg_profit:+.2f}")
        print(f"  Total Profit: ${total_profit:+.2f}")
        print(f"  Avg Abs Strength: {avg_signal_strength:.4f}")
 
    print("\n" + "="*60)
 
    results_df = pd.DataFrame(results)
 
    if len(results_df) > 0:
        best_bin = results_df.loc[results_df['win_rate'].idxmax()]
        worst_bin = results_df.loc[results_df['win_rate'].idxmin()]
 
        print("INSIGHTS:")
        print(f"  Best Bin: {best_bin['strength_bin']} (Win Rate: {best_bin['win_rate']:.1f}%)")
        print(f"  Worst Bin: {worst_bin['strength_bin']} (Win Rate: {worst_bin['win_rate']:.1f}%)")
 
        # Analyze weak vs strong signals
        weak_signals = trades_df[trades_df['abs_signal_strength'] < 0.10]
        strong_signals = trades_df[trades_df['abs_signal_strength'] >= 0.20]
 
        if len(weak_signals) > 0:
            weak_wr = (len(weak_signals[weak_signals['outcome']=='WIN']) / len(weak_signals)) * 100
            print(f"  Weak Signals (<0.10): {weak_wr:.1f}% win rate ({len(weak_signals)} trades)")
 
        if len(strong_signals) > 0:
            strong_wr = (len(strong_signals[strong_signals['outcome']=='WIN']) / len(strong_signals)) * 100
            print(f"  Strong Signals (≥0.20): {strong_wr:.1f}% win rate ({len(strong_signals)} trades)")
 
    print("="*60)
 
    return results_df
 
 
# ============================================================================
# MAIN
# ============================================================================
 
def main():
    print("\n" + "="*60)
    print("TRADE ANALYSIS WITH ATR OCTANT & SIGNAL STRENGTH")
    print("="*60)
 
    # Step 1: Load trades
    trades_df = load_trades_from_excel(TRADE_FILE)
 
    if len(trades_df) == 0:
        print("ERROR: No trades found!")
        return
 
    # Step 2: Match trades with signals
    trades_df = match_trades_with_signals(trades_df, SYMBOL)
 
    # Step 3: Assign ATR octants
    trades_df = assign_atr_octants(trades_df, SYMBOL, TIMEFRAME)
 
    # Step 4: Analyze by ATR octant
    octant_results = analyze_by_octant(trades_df)
 
    # Step 5: Analyze by signal strength
    signal_results = analyze_by_signal_strength(trades_df)
 
    # Save results
    output_file = r""
    trades_df.to_csv(output_file, index=False)
    print(f"\nFull trade data saved to: atr_octant_analysis.csv")
 
    # Save signal strength results if available
    if signal_results is not None:
        signal_output = r""
        signal_results.to_csv(signal_output, index=False)
        print(f"Signal strength analysis saved to: signal_strength_analysis.csv")
 
    print("\nDONE! :sparkles:")
 
 
if __name__ == "__main__":
    main()

"""
Monthly regime classification using Mandelbrot's fractal tools with MT5 data.
 
Uses proven MF-DFA methodology to identify favorable/unfavorable periods
for mean-reversion strategy.
 
Metrics:
--------
1. MF-DFA Generalized Hurst Exponent h(q)
2. Spectrum Width Evolution (multifractality measure)
3. Tail Index α (α-stable parameter estimation)
 
Output:
    PNG chart showing regime evolution over time with monthly calculations
"""
 
import sys
import pandas as pd
import numpy as np
import MetaTrader5 as mt5
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.gridspec import GridSpec
from scipy import stats
from MFDFA import MFDFA
import argparse
import warnings
warnings.filterwarnings('ignore')

 
class RegimeAnalyzerMT5:
    """
    Analyze market regimes using Mandelbrot's fractal framework with MT5 data.
    """
 
    def __init__(self, lookback_days: int = 60):
        """
        Initialize regime analyzer.
 
        Args:
            lookback_days: Number of trading days for rolling window analysis
        """
        self.lookback_days = lookback_days
 
    def calculate_mfdfa_hurst(self, returns: np.ndarray) -> Dict:
        """
        Compute Generalized Hurst Exponent h(q) using MF-DFA.
 
        Based on Mandelbrot's multifractal analysis framework.
        Returns h(q) for different moment orders q.
 
        Args:
            returns: Log returns time series
 
        Returns:
            Dictionary with h(q) values, spectrum width, and Hurst estimate
        """
        # Define lag range and q values
        lag = np.arange(10, min(100, len(returns)//4))
        q = np.array([-2, -1, 1, 2])  # Avoid q=0 for numerical stability
 
        try:
            # Perform MF-DFA
            lag_out, f = MFDFA(returns, lag=lag, q=q, order=1)
 
            # Calculate h(q) by fitting log-log for each q value
            h_q = np.zeros(len(q))
            for i in range(len(q)):
                # h(q) is the slope of log(F_q) vs log(s)
                coeffs = np.polyfit(np.log(lag_out), np.log(f[:, i]), 1)
                h_q[i] = coeffs[0]
 
        except Exception as e:
            # Default to random walk if calculation fails
            h_q = np.ones(len(q)) * 0.5
 
        # Spectrum width (degree of multifractality)
        spectrum_width = np.max(h_q) - np.min(h_q)
 
        # Spectrum asymmetry
        left_wing = h_q[1] - h_q[0]   # h(-1) - h(-2)
        right_wing = h_q[-1] - h_q[-2]  # h(2) - h(1)
        spectrum_asymmetry = right_wing - left_wing
 
        # Hurst exponent (use h(q=1) as proxy)
        hurst = h_q[2]  # h(q=1)
 
        return {
            'h_q': h_q,
            'q_values': q,
            'spectrum_width': spectrum_width,
            'spectrum_asymmetry': spectrum_asymmetry,
            'hurst': hurst
        }
 
    def estimate_tail_index(self, returns: np.ndarray, method: str = 'hill') -> float:
        """
        Estimate tail index α for α-stable distributions.
 
        Based on Mandelbrot's work on stable Paretian distributions.
        α < 2 indicates heavy tails (Lévy flights)
        α = 2 indicates Gaussian (thin tails)
 
        Args:
            returns: Return time series
            method: Estimation method ('hill' or 'moment')
 
        Returns:
            Estimated tail index α
        """
        if len(returns) < 50:
            return 2.0  # Default to Gaussian
 
        # Remove zeros and NaNs
        returns_clean = returns[np.isfinite(returns) & (returns != 0)]
 
        if len(returns_clean) < 50:
            return 2.0
 
        if method == 'hill':
            # Hill estimator for tail index
            # Uses extreme values (top 5% of absolute returns)
            abs_returns = np.abs(returns_clean)
            threshold_pct = 95
            threshold = np.percentile(abs_returns, threshold_pct)
 
            # Get exceedances
            exceedances = abs_returns[abs_returns > threshold]
 
            if len(exceedances) < 10:
                return 2.0
 
            # Hill estimator: α = 1 / mean(log(X_i / threshold))
            log_ratios = np.log(exceedances / threshold)
            alpha = 1.0 / np.mean(log_ratios)
 
            # Clip to valid range [0.1, 2.0]
            alpha = np.clip(alpha, 0.1, 2.0)
 
        else:  # moment method
            # Moment-based estimator using kurtosis
            kurt = stats.kurtosis(returns_clean, fisher=False)
 
            if kurt > 10:  # Heavy tails
                alpha = 2.0 / (1.0 + np.log10(kurt / 3.0))
            else:
                alpha = 2.0
 
            alpha = np.clip(alpha, 0.1, 2.0)
 
        return alpha
 
    def get_mt5_data(self, symbol: str, start_date: datetime,
                    end_date: datetime) -> pd.DataFrame:
        """
        Fetch daily data from MetaTrader5.
 
        Args:
            symbol: Currency pair symbol
            start_date: Start date (includes lookback)
            end_date: End date
 
        Returns:
            DataFrame with OHLC data
        """
        if not mt5.initialize():
            raise RuntimeError(f"MT5 initialization failed: {mt5.last_error()}")
 
        # Fetch daily bars
        rates = mt5.copy_rates_range(symbol, mt5.TIMEFRAME_D1, start_date, end_date)
 
        if rates is None or len(rates) == 0:
            mt5.shutdown()
            raise ValueError(f"No data retrieved for {symbol}")
 
        # Convert to DataFrame
        df = pd.DataFrame(rates)
        df['time'] = pd.to_datetime(df['time'], unit='s')
        df.rename(columns={'time': 'date'}, inplace=True)
 
        mt5.shutdown()
 
        print(f"Retrieved {len(df)} daily bars for {symbol}")
        return df
 
    def classify_regime(self, hurst: float, spectrum_width: float,
                       tail_index: float) -> str:
        """
        Classify regime based on fractal metrics.
 
        Args:
            hurst: Hurst exponent
            spectrum_width: Spectrum width
            tail_index: Tail index α
 
        Returns:
            Regime classification
        """
        # Check for turbulent conditions first
        if spectrum_width > 0.5:
            return 'TURBULENT'
 
        # Check holder exponent for trending vs mean-reverting
        if hurst < 0.45 and spectrum_width < 0.3:
            return 'MEAN_REVERTING'
        elif hurst > 0.55:
            return 'TRENDING'
        else:
            return 'NEUTRAL'
 
    def analyze_regime_evolution(self, symbol: str, start_date: str,
                                 end_date: str, output_path: str = None):
        """
        Analyze regime evolution using monthly rolling window.
 
        Args:
            symbol: Currency pair symbol
            start_date: Analysis start date (YYYY-MM-DD)
            end_date: Analysis end date (YYYY-MM-DD)
            output_path: Output PNG path
        """
        print(f"\n{'='*80}")
        print(f"REGIME ANALYZER - MT5")
        print(f"{'='*80}")
        print(f"Symbol: {symbol}")
        print(f"Period: {start_date} to {end_date}")
        print(f"Lookback: {self.lookback_days} trading days")
        print(f"Calculation Frequency: Monthly")
        print(f"{'='*80}\n")
 
        # Parse dates
        start_dt = datetime.strptime(start_date, '%Y-%m-%d')
        end_dt = datetime.strptime(end_date, '%Y-%m-%d')
 
        # Fetch data with extra lookback
        data_start = start_dt - timedelta(days=self.lookback_days + 30)
        df = self.get_mt5_data(symbol, data_start, end_dt)
 
        # Calculate log returns
        df['log_return'] = np.log(df['close'] / df['close'].shift(1))
        df = df.dropna()
 
        # Generate monthly calculation dates
        monthly_dates = pd.date_range(start=start_dt, end=end_dt, freq='MS')
 
        results = []
 
        print(f"\nCalculating regime metrics for {len(monthly_dates)} monthly points...")
 
        for calc_date in monthly_dates:
            print(f"\n{'-'*80}")
            print(f"Processing: {calc_date.date()}")
            print(f"{'-'*80}")
 
            # Get lookback window
            window_end = calc_date
            window_start = calc_date - timedelta(days=self.lookback_days + 30)
 
            window_df = df[(df['date'] >= window_start) & (df['date'] < window_end)]
 
            if len(window_df) < 30:
                print(f"  Insufficient data ({len(window_df)} bars), skipping...")
                continue
 
            # Use most recent lookback_days
            window_df = window_df.tail(self.lookback_days)
 
            print(f"  Using {len(window_df)} bars")
 
            # Prepare data
            returns = window_df['log_return'].values
 
            # Calculate MF-DFA metrics
            print("  Calculating MF-DFA...")
            mf_metrics = self.calculate_mfdfa_hurst(returns)
 
            # Calculate tail index
            print("  Calculating tail index...")
            alpha_hill = self.estimate_tail_index(returns, method='hill')
 
            # Classify regime
            regime = self.classify_regime(
                mf_metrics['hurst'],
                mf_metrics['spectrum_width'],
                alpha_hill
            )
 
            print(f"  Hurst: {mf_metrics['hurst']:.4f}")
            print(f"  Spectrum Width: {mf_metrics['spectrum_width']:.4f}")
            print(f"  Tail Index α: {alpha_hill:.4f}")
            print(f"  Regime: {regime}")
 
            results.append({
                'date': calc_date,
                'hurst': mf_metrics['hurst'],
                'spectrum_width': mf_metrics['spectrum_width'],
                'asymmetry': mf_metrics['spectrum_asymmetry'],
                'tail_index': alpha_hill,
                'regime': regime
            })
 
        if not results:
            print("\nNo results to visualize!")
            return
 
        results_df = pd.DataFrame(results)
 
        # Create visualization
        self._create_visualization(df, results_df, symbol, output_path)
 
        print(f"\n{'='*80}")
        print(f"Analysis complete!")
        print(f"{'='*80}\n")
 
    def _create_visualization(self, price_df: pd.DataFrame,
                             results_df: pd.DataFrame,
                             symbol: str, output_path: str = None):
        """
        Create PNG visualization of regime evolution.
        """
        fig = plt.figure(figsize=(24, 16))
        gs = GridSpec(5, 1, figure=fig, hspace=0.3)
 
        # Panel 1: Price chart
        ax1 = fig.add_subplot(gs[0, :])
        ax1.plot(price_df['date'], price_df['close'], color='blue',
                linewidth=1, alpha=0.7, label='Daily Close')
        ax1.set_ylabel('Price', fontsize=12, fontweight='bold')
        ax1.set_title(f'{symbol} - Daily Price Chart', fontsize=14, fontweight='bold')
        ax1.grid(True, alpha=0.3)
        ax1.legend(loc='upper left')
 
        # Panel 2: Hurst Exponent
        ax2 = fig.add_subplot(gs[1, :], sharex=ax1)
        ax2.plot(results_df['date'], results_df['hurst'],
                color='blue', linewidth=2, marker='o', label='Hurst H')
 
        # Reference lines
        ax2.axhline(y=0.45, color='red', linestyle=':', linewidth=1,
                   label='H=0.45 (Mean-reversion threshold)')
        ax2.axhline(y=0.55, color='green', linestyle=':', linewidth=1,
                   label='H=0.55 (Trending threshold)')
        ax2.axhline(y=0.5, color='gray', linestyle='--', linewidth=1,
                   label='H=0.5 (Random walk)')
 
        ax2.set_ylabel('Hurst H', fontsize=12, fontweight='bold')
        ax2.set_title('Generalized Hurst Exponent (MF-DFA)', fontsize=14, fontweight='bold')
        ax2.set_ylim(0, 1)
        ax2.grid(True, alpha=0.3)
        ax2.legend(loc='upper right', fontsize=9)
 
        # Panel 3: Spectrum Width
        ax3 = fig.add_subplot(gs[2, :], sharex=ax1)
        ax3.fill_between(results_df['date'], 0, results_df['spectrum_width'],
                        color='purple', alpha=0.3)
        ax3.plot(results_df['date'], results_df['spectrum_width'],
                color='purple', linewidth=2, marker='s', label='Spectrum Width')
 
        # Thresholds
        ax3.axhline(y=0.3, color='green', linestyle=':', linewidth=1,
                   label='Width=0.3 (Stable threshold)')
        ax3.axhline(y=0.5, color='orange', linestyle=':', linewidth=1,
                   label='Width=0.5 (Turbulent threshold)')
 
        ax3.set_ylabel('Width', fontsize=12, fontweight='bold')
        ax3.set_title('Spectrum Width (Multifractality)', fontsize=14, fontweight='bold')
        ax3.grid(True, alpha=0.3)
        ax3.legend(loc='upper right', fontsize=9)
 
        # Panel 4: Tail Index
        ax4 = fig.add_subplot(gs[3, :], sharex=ax1)
        ax4.plot(results_df['date'], results_df['tail_index'],
                color='red', linewidth=2, marker='d', label='Tail Index α (Hill)')
 
        # Reference lines
        ax4.axhline(y=2.0, color='gray', linestyle='--', linewidth=1,
                   label='α=2.0 (Gaussian)')
        ax4.axhline(y=1.5, color='orange', linestyle=':', linewidth=1,
                   label='α=1.5 (Heavy tails)')
 
        ax4.set_ylabel('α', fontsize=12, fontweight='bold')
        ax4.set_title('Tail Index α (Hill Estimator)', fontsize=14, fontweight='bold')
        ax4.set_ylim(0, 2.5)
        ax4.grid(True, alpha=0.3)
        ax4.legend(loc='upper right', fontsize=9)
 
        # Panel 5: Regime Classification
        ax5 = fig.add_subplot(gs[4, :], sharex=ax1)
 
        # Map regimes to colors
        regime_colors = {
            'MEAN_REVERTING': 'green',
            'TRENDING': 'red',
            'TURBULENT': 'orange',
            'NEUTRAL': 'yellow'
        }
 
        # Plot regime zones
        for i in range(len(results_df)):
            date = results_df.iloc[i]['date']
            regime = results_df.iloc[i]['regime']
            color = regime_colors.get(regime, 'gray')
 
            # Draw vertical span for this month
            if i < len(results_df) - 1:
                next_date = results_df.iloc[i+1]['date']
            else:
                next_date = date + timedelta(days=30)
 
            ax5.axvspan(date, next_date, alpha=0.3, color=color)
 
        # Add legend
        from matplotlib.patches import Patch
        legend_elements = [
            Patch(facecolor='green', alpha=0.3, label='MEAN_REVERTING (Trade)'),
            Patch(facecolor='yellow', alpha=0.3, label='NEUTRAL (Caution)'),
            Patch(facecolor='red', alpha=0.3, label='TRENDING (Skip)'),
            Patch(facecolor='orange', alpha=0.3, label='TURBULENT (Skip)')
        ]
 
        ax5.set_ylabel('Regime', fontsize=12, fontweight='bold')
        ax5.set_xlabel('Date', fontsize=12, fontweight='bold')
        ax5.set_title('Regime Classification', fontsize=14, fontweight='bold')
        ax5.set_ylim(0, 1)
        ax5.set_yticks([])
        ax5.legend(handles=legend_elements, loc='upper right', fontsize=10)
        ax5.grid(True, alpha=0.3, axis='x')
 
        # Format x-axis
        ax5.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
        ax5.xaxis.set_major_locator(mdates.MonthLocator())
        ax5.tick_params(axis='x', rotation=45)
 
        # Main title
        plt.suptitle(f'Regime Analysis - {symbol} (MF-DFA Method)',
                    fontsize=18, fontweight='bold', y=0.995)
 
        plt.tight_layout()
 
        # Save
        if output_path is None:
            output_path = f"regime_analysis_{symbol}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
 
        plt.savefig(output_path, dpi=150, bbox_inches='tight')
        print(f"Chart saved to: {output_path}")
        plt.close()

 
def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description='Tegime analyzer using MT5 data and MF-DFA',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
 
    parser.add_argument('symbol', type=str, help='Currency pair symbol (e.g., EURUSD)')
    parser.add_argument('start_date', type=str, help='Start date (YYYY-MM-DD)')
    parser.add_argument('end_date', type=str, help='End date (YYYY-MM-DD)')
    parser.add_argument('--lookback', type=int, default=60,
                       help='Lookback window in trading days (default: 60)')
    parser.add_argument('--output', '-o', type=str, default=None,
                       help='Output PNG file path')
 
    args = parser.parse_args()
 
    # Run analysis
    analyzer = RegimeAnalyzerMT5(lookback_days=args.lookback)
    analyzer.analyze_regime_evolution(
        args.symbol,
        args.start_date,
        args.end_date,
        args.output
    )

 
if __name__ == "__main__":
    main()

Quoting pusztafie

Disliked

EA behaved well today, generating profits. {image}

Ignored

Quoting cfudge

Disliked

{quote} Mine may also do that next week. What do you think the reason is between our accounts results...is it just the settings or the broker feed...

Ignored

Quoting RogerCS

Disliked

{quote} In my opinion, the entries are not bad. In this new version, the partials and BE feature are excellent. One thing I find interesting is trying a slightly different closing to ride the trend more, I have no idea how to do that, but if done, it will converge better. I liked the overall management of the EA, and I have a lot of confidence in it, but sometimes it loses a lot of the potential of a longer trend.

Ignored

Quoting pusztafie

Disliked

{quote} I can't find a break even function in EA, could you please show me where I can find it?

Ignored

Quoting RogerCS

Disliked

{quote} Maybe this will help, I activated the BE feature and partial closings, and entries with a fixed lot... I believe this will help, the other settings are default. and I activated with 1 loss protection, it took the loss only enters on the next H1 signal {file} {file}

Ignored

Quoting cfudge

Disliked

5 Days data multi same as last week ...no changes {image}

Ignored

Quoting cfudge

Disliked

{quote} 6 days in multi {image}

Ignored