apex_trail_sim.py

"""
Baseline: DUAL entry + SL only. NO trailing, NO TP.
Compare with Apex Trail to see if trailing adds value.
"""
import pyarrow.parquet as pq
import numpy as np
from numba import njit
import time as time_mod

PT = 0.01; PV = 1.0

print("Loading tickflow_M1...")
df = pq.read_table("C:/Users/Black/Downloads/MT5EA/tick_data/tickflow_M1.parquet").to_pandas()
tr = np.maximum(df['high']-df['low'],
       np.maximum(np.abs(df['high']-df['close'].shift(1).fillna(df['close'])),
                  np.abs(df['low']-df['close'].shift(1).fillna(df['close']))))
df['atr'] = (tr.rolling(210, min_periods=14).mean() / PT).fillna(300)
df['sp'] = df['spread_avg']

G_c=df['close'].values.astype(np.float64)
G_h=df['high'].values.astype(np.float64)
G_l=df['low'].values.astype(np.float64)
G_ac=df['ask_close'].values.astype(np.float64)
G_ao=df['ask_open'].values.astype(np.float64)
G_o=df['open'].values.astype(np.float64)
G_sp=df['sp'].values.astype(np.float64)
G_atr=df['atr'].values.astype(np.float64)
G_tc=df['tick_count'].values.astype(np.float64)
N=len(df)
del df

@njit(cache=True)
def sim_no_trail(c,h,l,ac,ao,o,sp,atr,tc,N, sl_atr, entry_interval, tick_thresh):
    MX=60000
    p_s=np.zeros(MX,np.int8); p_e=np.zeros(MX,np.float64)
    p_atr=np.zeros(MX,np.float64); p_op=np.zeros(MX,np.bool_)
    p_pnl=np.zeros(MX,np.float64)
    pc=0; last_e=-999

    for i in range(N):
        B=c[i]; A=ac[i]; BH=h[i]; BL=l[i]; SP=sp[i]; ATR=atr[i]
        AH=BH+SP*PT

        for j in range(pc):
            if not p_op[j]: continue
            si=p_s[j]; en=p_e[j]; sl_pts=p_atr[j]*sl_atr
            if si==1:
                pp_w=(BL-en)/PT
            else:
                pp_w=(en-AH)/PT
            if pp_w<=-sl_pts:
                p_op[j]=False; p_pnl[j]=-(sl_pts*PV/100.0)

        if i-last_e>=entry_interval and SP<40 and pc+2<=MX:
            if tc[i]>=tick_thresh:
                last_e=i
                for k in range(2):
                    si2=1 if k==0 else -1
                    ep=ao[i] if si2==1 else o[i]
                    p_s[pc]=si2; p_e[pc]=ep; p_atr[pc]=ATR
                    p_op[pc]=True; p_pnl[pc]=0.0; pc+=1
            else:
                last_e=i

    for j in range(pc):
        if p_op[j]:
            si=p_s[j]
            if si==1: ppts=(c[N-1]-p_e[j])/PT
            else: ppts=(p_e[j]-ac[N-1])/PT
            p_pnl[j]=ppts*PV/100.0; p_op[j]=False
    return p_pnl[:pc]

# Same with Apex Trail best params
@njit(cache=True)
def sim_apex(c,h,l,ac,ao,o,sp,tv,atr,adx,tc,N,
             sl_atr,trail_start,p2_trend,p2_norm,p2_side,p3_sq,
             entry_interval,tick_thresh,tv_exhaust,tv_recover):
    MX=60000
    p_s=np.zeros(MX,np.int8); p_e=np.zeros(MX,np.float64)
    p_sl=np.zeros(MX,np.float64); p_ph=np.zeros(MX,np.int8)
    p_pk=np.zeros(MX,np.float64); p_pkp=np.zeros(MX,np.float64)
    p_op=np.zeros(MX,np.bool_); p_pnl=np.zeros(MX,np.float64)
    p_atr_e=np.zeros(MX,np.float64)
    pc=0; last_e=-999

    for i in range(N):
        B=c[i]; A=ac[i]; BH=h[i]; BL=l[i]
        SP=sp[i]; TV=tv[i]; ATR=atr[i]; ADX=adx[i]
        AH=BH+SP*PT; AL=BL+SP*PT
        for j in range(pc):
            if not p_op[j]: continue
            si=p_s[j]; en=p_e[j]; ea=p_atr_e[j]
            sl_pts=ea*sl_atr
            if si==1: pp_w=(BL-en)/PT; pp_b=(BH-en)/PT
            else: pp_w=(en-AH)/PT; pp_b=(en-AL)/PT
            if pp_b>p_pkp[j]:
                p_pkp[j]=pp_b
                p_pk[j]=BH if si==1 else AL
            if pp_w<=-sl_pts:
                p_op[j]=False; p_pnl[j]=-(sl_pts*PV/100.0); continue
            if p_ph[j]==0 and pp_b>=ATR*trail_start:
                p_ph[j]=2
                m=p2_trend if ADX>30 else (p2_norm if ADX>20 else p2_side)
                pk=p_pk[j]
                if si==1:
                    ns=pk-ATR*m*PT; ns=max(ns,en); p_sl[j]=ns
                else:
                    ns=pk+ATR*m*PT; ns=min(ns,en); p_sl[j]=ns
            if p_ph[j]==2:
                m=p2_trend if ADX>30 else (p2_norm if ADX>20 else p2_side)
                td=ATR*m*PT; pk=p_pk[j]
                if si==1:
                    ns=pk-td; ns=max(ns,en)
                    if ns>p_sl[j]: p_sl[j]=ns
                else:
                    ns=pk+td; ns=min(ns,en)
                    if p_sl[j]<=0 or ns<p_sl[j]: p_sl[j]=ns
                if TV<tv_exhaust and p_pkp[j]>ATR*1.5: p_ph[j]=3
            if p_ph[j]==3:
                sq=ATR*p3_sq*PT; pk=p_pk[j]
                if si==1:
                    ns=pk-sq; ns=max(ns,en)
                    if ns>p_sl[j]: p_sl[j]=ns
                else:
                    ns=pk+sq; ns=min(ns,en)
                    if p_sl[j]<=0 or ns<p_sl[j]: p_sl[j]=ns
                if TV>tv_recover: p_ph[j]=2
            if p_ph[j]>=2 and p_sl[j]>0:
                hit=False
                if si==1 and BL<=p_sl[j]: hit=True
                elif si==-1 and AH>=p_sl[j]: hit=True
                if hit:
                    ppts=(p_sl[j]-en)/PT if si==1 else (en-p_sl[j])/PT
                    p_op[j]=False; p_pnl[j]=ppts*PV/100.0
        if i-last_e>=entry_interval and SP<40 and pc+2<=MX:
            if tc[i]>=tick_thresh:
                last_e=i
                for k in range(2):
                    si2=1 if k==0 else -1
                    ep=ao[i] if si2==1 else o[i]
                    p_s[pc]=si2; p_e[pc]=ep
                    sl_d=ATR*sl_atr*PT
                    p_sl[pc]=ep-sl_d if si2==1 else ep+sl_d
                    p_ph[pc]=0; p_pk[pc]=ep; p_pkp[pc]=0.0
                    p_op[pc]=True; p_pnl[pc]=0.0; p_atr_e[pc]=ATR; pc+=1
            else:
                last_e=i
    for j in range(pc):
        if p_op[j]:
            si=p_s[j]
            ppts=(c[N-1]-p_e[j])/PT if si==1 else (p_e[j]-ac[N-1])/PT
            p_pnl[j]=ppts*PV/100.0; p_op[j]=False
    return p_pnl[:pc]

# Need TV and ADX for apex
df2 = pq.read_table("C:/Users/Black/Downloads/MT5EA/tick_data/tickflow_M1.parquet").to_pandas()
tr2 = np.maximum(df2['high']-df2['low'],
       np.maximum(np.abs(df2['high']-df2['close'].shift(1).fillna(df2['close'])),
                  np.abs(df2['low']-df2['close'].shift(1).fillna(df2['close']))))
df2['atr'] = (tr2.rolling(210, min_periods=14).mean() / PT).fillna(300)
dm = df2['close'].diff().abs() / PT
df2['adx'] = (dm.rolling(210, min_periods=14).mean() / df2['atr'].clip(lower=1) * 50).clip(upper=60).fillna(25)
df2['tv'] = df2['tick_count'].rolling(5, min_periods=1).mean() / 60.0
G_tv=df2['tv'].values.astype(np.float64)
G_adx=df2['adx'].values.astype(np.float64)
del df2

tick25 = float(np.percentile(G_tc, 25))

print("JIT warmup...")
_ = sim_no_trail(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_atr,G_tc,N, 2.0, 3, tick25)
_ = sim_apex(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_tv,G_atr,G_adx,G_tc,N,
             2.0,3.0,2.25,0.75,0.7,0.2, 3,tick25,0.75,8.0)

def report(name, pnls):
    n=len(pnls); wins=int(np.sum(pnls>0)); losses=n-wins
    ws=float(np.sum(pnls[pnls>0])); ls=float(np.sum(pnls[pnls<=0]))
    aw=float(np.mean(pnls[pnls>0])) if wins else 0
    al=float(np.mean(pnls[pnls<=0])) if losses else 0
    pf=abs(ws)/max(0.01,abs(ls))
    exp=float(np.mean(pnls))
    wr=wins/n*100
    print(f"\n  {name}")
    print(f"  Trades:{n} WR:{wr:.1f}% PF:{pf:.2f} Exp:${exp:.2f}")
    print(f"  AvgW:${aw:.2f} AvgL:${al:.2f} W/L:{abs(aw/al) if al else 0:.2f}")
    print(f"  Total:${np.sum(pnls):.0f} | Balance:${500+np.sum(pnls):.0f}")
    return pf, exp, np.sum(pnls)

print(f"\n{'='*60}")
print(f"COMPARISON: No Trail vs Apex Trail (Optuna Best)")
print(f"{'='*60}")

# 1. NO TRAIL - SL only
t0=time_mod.time()
pnls1 = sim_no_trail(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_atr,G_tc,N, 2.0, 3, tick25)
t1=time_mod.time()-t0
pf1, exp1, tot1 = report("A) NO TRAILING (SL=2xATR only)", pnls1)

# 2. APEX TRAIL (Optuna best: SL=2, TS=3, P2t=2.25, P2n=0.75, P2s=0.7, P3=0.2, BE=True)
t0=time_mod.time()
pnls2 = sim_apex(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_tv,G_atr,G_adx,G_tc,N,
                 2.0, 3.0, 2.25, 0.75, 0.7, 0.2, 3, tick25, 0.75, 8.0)
t2=time_mod.time()-t0
pf2, exp2, tot2 = report("B) APEX TRAIL (Optuna Best)", pnls2)

# 3. Simple TP = 1xATR, SL = 2xATR (classic 1:2 risk-reward reversed)
@njit(cache=True)
def sim_fixed_tp(c,h,l,ac,ao,o,sp,atr,tc,N, sl_atr, tp_atr, entry_interval, tick_thresh):
    MX=60000
    p_s=np.zeros(MX,np.int8); p_e=np.zeros(MX,np.float64)
    p_atr=np.zeros(MX,np.float64); p_op=np.zeros(MX,np.bool_)
    p_pnl=np.zeros(MX,np.float64)
    pc=0; last_e=-999
    for i in range(N):
        B=c[i]; A=ac[i]; BH=h[i]; BL=l[i]; SP=sp[i]; ATR=atr[i]
        AH=BH+SP*PT; AL=BL+SP*PT
        for j in range(pc):
            if not p_op[j]: continue
            si=p_s[j]; en=p_e[j]; ea=p_atr[j]
            sl_pts=ea*sl_atr; tp_pts=ea*tp_atr
            if si==1:
                pp_w=(BL-en)/PT; pp_b=(BH-en)/PT
            else:
                pp_w=(en-AH)/PT; pp_b=(en-AL)/PT
            if pp_w<=-sl_pts:
                p_op[j]=False; p_pnl[j]=-(sl_pts*PV/100.0); continue
            if pp_b>=tp_pts:
                p_op[j]=False; p_pnl[j]=tp_pts*PV/100.0
        if i-last_e>=entry_interval and SP<40 and pc+2<=MX:
            if tc[i]>=tick_thresh:
                last_e=i
                for k in range(2):
                    si2=1 if k==0 else -1
                    ep=ao[i] if si2==1 else o[i]
                    p_s[pc]=si2; p_e[pc]=ep; p_atr[pc]=ATR
                    p_op[pc]=True; p_pnl[pc]=0.0; pc+=1
            else:
                last_e=i
    for j in range(pc):
        if p_op[j]:
            si=p_s[j]
            ppts=(c[N-1]-p_e[j])/PT if si==1 else (p_e[j]-ac[N-1])/PT
            p_pnl[j]=ppts*PV/100.0; p_op[j]=False
    return p_pnl[:pc]

# Warmup
_ = sim_fixed_tp(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_atr,G_tc,N, 2.0, 0.5, 3, tick25)

# Test multiple TP/SL ratios
print(f"\n{'='*60}")
print(f"C) FIXED TP/SL GRID SEARCH")
print(f"{'='*60}")
best_pf = 0; best_combo = ""
for sl in [1.0, 1.5, 2.0, 3.0]:
    for tp in [0.3, 0.5, 1.0, 1.5, 2.0, 3.0]:
        pnls3 = sim_fixed_tp(G_c,G_h,G_l,G_ac,G_ao,G_o,G_sp,G_atr,G_tc,N, sl, tp, 3, tick25)
        n=len(pnls3); ws=float(np.sum(pnls3[pnls3>0])); ls=float(np.sum(pnls3[pnls3<=0]))
        pf=abs(ws)/max(0.01,abs(ls)); wins=int(np.sum(pnls3>0)); wr=wins/n*100
        exp=float(np.mean(pnls3)); tot=float(np.sum(pnls3))
        flag = " <<<" if pf > best_pf else ""
        if pf > best_pf: best_pf=pf; best_combo=f"SL={sl} TP={tp}"
        print(f"  SL={sl:.1f}xATR TP={tp:.1f}xATR | WR:{wr:.0f}% PF:{pf:.2f} Exp:${exp:.2f} Total:${tot:.0f}{flag}")

print(f"\n  BEST: {best_combo} | PF={best_pf:.2f}")

print(f"\n{'='*60}")
print(f"SUMMARY")
print(f"{'='*60}")
print(f"  A) No Trail:    PF={pf1:.2f} PnL=${tot1:.0f}")
print(f"  B) Apex Trail:  PF={pf2:.2f} PnL=${tot2:.0f}")
print(f"  C) Best TP/SL:  PF={best_pf:.2f} ({best_combo})")