Upload simulate_v4_1_trailing.py with huggingface_hub

simulate_v4_1_trailing.py

@@ -0,0 +1,120 @@
+import pandas as pd
+import numpy as np
+
+def run_simulation():
+    print("--- U2Predator V4.1 Trailing Simulator ---")
+    df = pd.read_parquet('native_rates_M1.parquet')
+    
+    # Calculate Donchian Channels
+    df['dc_fast_h'] = df['high'].rolling(14).max()
+    df['dc_fast_l'] = df['low'].rolling(14).min()
+    df['dc_fast_mid'] = (df['dc_fast_h'] + df['dc_fast_l']) / 2
+
+    df['dc_slow_h'] = df['high'].rolling(21).max()
+    df['dc_slow_l'] = df['low'].rolling(21).min()
+    df['dc_slow_mid'] = (df['dc_slow_h'] + df['dc_slow_l']) / 2
+    
+    df['mid_gap'] = df['dc_fast_mid'] - df['dc_slow_mid']
+    
+    # Shift to prevent lookahead
+    df['dc_f_mid_1'] = df['dc_fast_mid'].shift(1)
+    df['dc_s_mid_1'] = df['dc_slow_mid'].shift(1)
+    
+    df['mid_upper'] = df[['dc_f_mid_1', 'dc_s_mid_1']].max(axis=1)
+    df['mid_lower'] = df[['dc_f_mid_1', 'dc_s_mid_1']].min(axis=1)
+
+    # Simplified Entry: True Crossover + Expansion
+    df['is_bull_cross'] = (df['open'].shift(1) < df['mid_upper']) & (df['close'].shift(1) > df['mid_upper'])
+    df['is_bear_cross'] = (df['open'].shift(1) > df['mid_lower']) & (df['close'].shift(1) < df['mid_lower'])
+    
+    df['gap_expansion'] = df['mid_gap'].abs() >= 1.00 # 100 pts
+    
+    # Entry Signals
+    df['signal'] = 0
+    df.loc[df['is_bull_cross'] & df['gap_expansion'] & (df['mid_gap'] > 0), 'signal'] = 1
+    df.loc[df['is_bear_cross'] & df['gap_expansion'] & (df['mid_gap'] < 0), 'signal'] = -1
+    
+    # Simulate Trades
+    trades = []
+    in_trade = False
+    trade_dir = 0
+    entry_price = 0
+    hard_sl = 0
+    locked_sl = 0
+    max_float = 0
+    
+    points = 0.01 # Assuming 2 decimal pricing for Gold, 1 point = 0.01 (Wait, MT5 XAUUSD pnt = 0.01)
+    
+    for row in df.itertuples():
+        if getattr(row, 'signal') == 1 and not in_trade:
+            in_trade = True
+            trade_dir = 1
+            entry_price = getattr(row, 'open')
+            hard_sl = entry_price - 21.00 # 2100 pts SL Mode A
+            locked_sl = hard_sl
+            max_float = 0
+            continue
+            
+        if getattr(row, 'signal') == -1 and not in_trade:
+            in_trade = True
+            trade_dir = -1
+            entry_price = getattr(row, 'open')
+            hard_sl = entry_price + 21.00
+            locked_sl = hard_sl
+            max_float = 0
+            continue
+            
+        if in_trade:
+            if trade_dir == 1:
+                current_high_float = (getattr(row, 'high') - entry_price) / points
+                current_low_float = (getattr(row, 'low') - entry_price) / points
+                close_float = (getattr(row, 'close') - entry_price) / points
+                
+                max_float = max(max_float, current_high_float)
+                
+                # Check Lock Updates (evaluate HIGH of candle)
+                if max_float >= 600:
+                    locked_sl = max(locked_sl, entry_price + 5.00) # Stage 3 Lock 500pts minimum
+                elif max_float >= 450:
+                    locked_sl = max(locked_sl, entry_price + 3.50) # Stage 2 Lock 350pts
+                elif max_float >= 350:
+                    locked_sl = max(locked_sl, entry_price + 3.00) # Stage 1 Lock 300pts
+                
+                # Check Exit (evaluate LOW of candle against SL)
+                if getattr(row, 'low') <= locked_sl:
+                    pnl = (locked_sl - entry_price) / points
+                    pnl -= 50 # 50 pts Spread penalty
+                    trades.append(pnl)
+                    in_trade = False
+                    
+            elif trade_dir == -1:
+                current_high_float = (entry_price - getattr(row, 'low')) / points
+                current_low_float = (entry_price - getattr(row, 'high')) / points
+                
+                max_float = max(max_float, current_high_float)
+                
+                if max_float >= 600:
+                    locked_sl = min(locked_sl, entry_price - 5.00)
+                elif max_float >= 450:
+                    locked_sl = min(locked_sl, entry_price - 3.50)
+                elif max_float >= 350:
+                    locked_sl = min(locked_sl, entry_price - 3.00)
+                    
+                if getattr(row, 'high') >= locked_sl:
+                    pnl = (entry_price - locked_sl) / points
+                    pnl -= 50 # 50 pts Spread penalty
+                    trades.append(pnl)
+                    in_trade = False
+
+    t_df = pd.Series(trades)
+    print(f"Total Trades: {len(t_df)}")
+    if len(t_df) > 0:
+        print(f"Wins: {len(t_df[t_df > 0])}")
+        print(f"Losses: {len(t_df[t_df < 0])}")
+        print(f"Win Rate: {(len(t_df[t_df > 0]) / len(t_df))*100:.2f}%")
+        print(f"Avg Win: {t_df[t_df > 0].mean():.2f} pts")
+        print(f"Avg Loss: {t_df[t_df < 0].mean():.2f} pts")
+        print(f"Net Profit Expected: {t_df.sum():.2f} pts")
+
+if __name__ == '__main__':
+    run_simulation()