Update app.py

app.py

@@ -29,6 +29,7 @@ RR_GRID = [1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0]
 CLASSES = [-1, 0, 1]
 SIDE_MODES = ["Long + Short", "Sadece Long", "Sadece Short"]
 IND_MODES = ["Kapalı", "Onay filtresi (KNN + ST/UT)", "Sadece indikatör"]
+LDC_MODES = ["Kapalı", "Onay filtresi (Lorentzian)", "Sadece Lorentzian"]
 VP_MODES = ["Kapalı", "Onay filtresi (POC / Value Area)", "KNN özelliği + onay filtresi"]
 
 _CACHE = {}
@@ -216,6 +217,129 @@ def vp_signal(df, atr, vp, ext_atr):
     return np.where(ok_l, 1, np.where(ok_s, -1, 0)).astype(int)
 
 
+# ------------------------------------------- Lorentzian Classification (jdehorty) portu
+def adx_wilder(df, n=14):
+    h, l, c = df.High, df.Low, df.Close
+    up, dn = h.diff(), -l.diff()
+    plus = pd.Series(np.where((up > dn) & (up > 0), up, 0.0), index=df.index)
+    minus = pd.Series(np.where((dn > up) & (dn > 0), dn, 0.0), index=df.index)
+    tr = pd.concat([(h-l), (h-c.shift(1)).abs(), (l-c.shift(1)).abs()], axis=1).max(axis=1)
+    a = 1/n
+    atr = tr.ewm(alpha=a, adjust=False).mean()
+    pdi = 100*plus.ewm(alpha=a, adjust=False).mean()/atr
+    mdi = 100*minus.ewm(alpha=a, adjust=False).mean()/atr
+    dx = 100*(pdi-mdi).abs()/(pdi+mdi).replace(0, np.nan)
+    return dx.ewm(alpha=a, adjust=False).mean().to_numpy(float)
+
+
+def _norm01(x):
+    """Geçmiş min/max'a göre 0-1 ölçekleme (TV 'normalize'); yalnızca geçmişe bakar."""
+    s = pd.Series(x)
+    lo, hi = s.cummin(), s.cummax()
+    return ((s-lo)/(hi-lo).replace(0, np.nan)).to_numpy(float)
+
+
+def _ldc_features(df):
+    src = (df.High+df.Low+df.Close)/3
+    ema = lambda s, n: s.ewm(span=max(int(n), 1), adjust=False).mean()
+    rsi = lambda n: ema(calc_rsi(src, n)/100, 1).to_numpy(float)
+    e1 = ema(src, 10)
+    e2 = ema((src-e1).abs(), 10)
+    wt1 = ema((src-e1)/(0.015*e2).replace(0, np.nan), 11)
+    wt = _norm01((wt1-wt1.rolling(4).mean()).to_numpy(float))
+    ma = src.rolling(20).mean()
+    md = src.rolling(20).apply(lambda a: np.abs(a-a.mean()).mean(), raw=True)
+    cci = _norm01(((src-ma)/(0.015*md.replace(0, np.nan))).to_numpy(float))
+    adx = adx_wilder(df, 20)/100
+    # varsayılan öznitelikler: RSI(14,1), WT(10,11), CCI(20,1), ADX(20,2), RSI(9,1)
+    return np.column_stack([rsi(14), wt, cci, adx, rsi(9)]), src.to_numpy(float)
+
+
+def ldc_classify(df, k=8, max_back=2000, regime_thr=-0.1, kern_lb=8, kern_rw=8.0, x0=25,
+                 use_vol=True, use_regime=True, use_adx=False, adx_thr=20, use_kernel=True, exact=True):
+    """Machine Learning: Lorentzian Classification (jdehorty) Python portu.
+    Lorentzian mesafe = sum(log(1+|x-y|)); exact=True: gerçek k-NN, False: Pine'ın yaklaşık-NN döngüsü;
+    etiket = 4 bar sonraki yön. Filtreler: volatilite, rejim (Kalman eğimi), ADX; kernel:
+    Nadaraya-Watson rational quadratic. Her mum yalnızca kendisine kadarki veriyi kullanır.
+    state: +1 / -1 (ML sinyali + kernel eğimi aynı yönde), 0 onay yok."""
+    n = len(df)
+    F, s = _ldc_features(df)
+    y = np.full(n, np.nan)
+    y[:-4] = np.sign(s[4:]-s[:-4])
+    ok_f = np.isfinite(F).all(axis=1)
+    cand = ok_f & np.isfinite(y) & (np.arange(n) % 4 != 0)
+    kk = int(k)
+    cut = int(np.floor(kk*0.75+0.5))
+    pred = np.zeros(n)
+    for t in range(60, n):
+        if not ok_f[t]:
+            continue
+        hi_j = t-4                       # etiketi t'de bilinen son örnek
+        lo_j = max(0, hi_j-int(max_back)+1)
+        sel = np.flatnonzero(cand[lo_j:hi_j+1]) + lo_j
+        if len(sel) < kk:
+            continue
+        D = np.log1p(np.abs(F[sel]-F[t])).sum(axis=1)
+        if exact:   # gerçek k en yakın komşu (Lorentzian mesafe)
+            nn_ = np.argpartition(D, kk-1)[:kk]
+            pred[t] = y[sel][nn_].sum()
+            continue
+        last, dist, pr = -1.0, [], []   # Pine'ın kronolojik yaklaşık-NN döngüsü
+        for d, yv in zip(D.tolist(), y[sel].tolist()):
+            if d >= last:
+                dist.append(d)
+                pr.append(yv)
+                if len(dist) > kk:
+                    last = dist[cut]
+                    dist.pop(0)
+                    pr.pop(0)
+        pred[t] = sum(pr)
+
+    # --- filtreler
+    f_vol = (calc_atr(df, 1).to_numpy(float) > calc_atr(df, 10).to_numpy(float)) if use_vol \
+        else np.ones(n, bool)
+    f_reg = np.ones(n, bool)
+    if use_regime:
+        o4 = ((df.Open+df.High+df.Low+df.Close)/4).to_numpy(float)
+        hl = (df.High-df.Low).to_numpy(float)
+        v1 = v2 = kl = 0.0
+        klmf = np.zeros(n)
+        for i in range(n):
+            v1 = 0.2*(o4[i]-(o4[i-1] if i else o4[i]))+0.8*v1
+            v2 = 0.1*hl[i]+0.8*v2
+            om = abs(v1/v2) if v2 else 0.0
+            al = (-om**2+np.sqrt(om**4+16*om**2))/8
+            kl = al*o4[i]+(1-al)*kl
+            klmf[i] = kl
+        slope = pd.Series(np.abs(np.diff(klmf, prepend=klmf[0])))
+        ema_s = slope.ewm(span=200, adjust=False).mean()
+        f_reg = (((slope-ema_s)/ema_s.replace(0, np.nan)) >= float(regime_thr)).fillna(False).to_numpy(bool)
+    f_adx = (adx_wilder(df, 14) > float(adx_thr)) if use_adx else np.ones(n, bool)
+    filt = f_vol & f_reg & f_adx
+
+    sig = np.zeros(n, dtype=int)
+    for t in range(1, n):
+        sig[t] = 1 if (pred[t] > 0 and filt[t]) else -1 if (pred[t] < 0 and filt[t]) else sig[t-1]
+
+    # --- kernel regresyon (rational quadratic), yalnızca geçmiş barlar
+    L = int(kern_lb)+int(x0)
+    i_ = np.arange(L+1)
+    w = (1+i_**2/(float(kern_lb)**2*2*float(kern_rw)))**(-float(kern_rw))
+    yhat = np.full(n, np.nan)
+    for t in range(n):
+        m = min(L+1, t+1)
+        yhat[t] = (w[:m]*s[t-np.arange(m)]).sum()/w[:m].sum()
+    bull = np.r_[False, yhat[1:] > yhat[:-1]]
+    bear = np.r_[False, yhat[1:] < yhat[:-1]]
+    if use_kernel:
+        state = np.where((sig == 1) & bull, 1, np.where((sig == -1) & bear, -1, 0)).astype(int)
+    else:
+        state = sig.copy()
+    state[:60] = 0
+    return {"state": state, "signal": sig, "pred": pred, "yhat": yhat,
+            "vol": f_vol, "reg": f_reg, "adx": f_adx}
+
+
 def regime_labels(features, ref_vol):
     # Volatilite kantilleri yalnızca geliştirme dönemi verisinden alınır (sızıntı yok).
     q1, q2 = ref_vol.dropna().quantile([0.33, 0.67])
@@ -417,7 +541,8 @@ TRADE_COLS = ["entry_date", "exit_date", "side", "entry_price", "exit_reason",
 
 
 # ---------------------------------------------------------------- grafikler
-def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=None, vp_prof=None):
+def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=None, vp_prof=None,
+                 ldc=None):
     w = df.tail(150)
     sub = vp is not None and vp_prof is not None
     if sub:
@@ -455,6 +580,21 @@ def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=Non
                              marker_color=colors, name="Volume Profile", showlegend=False,
                              hoverinfo="skip"), row=1, col=2)
         fig.update_xaxes(showticklabels=False, row=1, col=2)
+    if ldc is not None:
+        yh = np.asarray(ldc["yhat"])[-150:]
+        rising = np.r_[False, np.diff(yh) > 0]
+        for flag, col, nm in [(True, "#16a34a", "Lorentzian kernel ↑"), (False, "#dc2626", "Lorentzian kernel ↓")]:
+            fig.add_trace(go.Scatter(x=w.index, y=np.where(rising == flag, yh, np.nan), mode="lines",
+                                     name=nm, line=dict(width=2, color=col)), **kw)
+        st_ = np.asarray(ldc["state"])[-150:]
+        prev = np.r_[0, st_[:-1]]
+        for d, nm, col, ycol, off in [(1, "LDC long", "#15803d", "Low", 0.995),
+                                      (-1, "LDC short", "#b91c1c", "High", 1.005)]:
+            m_ = (st_ == d) & (prev != d)
+            if m_.any():
+                fig.add_trace(go.Scatter(x=w.index[m_], y=w[ycol].to_numpy()[m_]*off, mode="markers",
+                                         name=nm, marker=dict(symbol="diamond", size=8, color=col,
+                                                              line=dict(width=1, color="white"))), **kw)
     if len(trades_df):
         t = trades_df[trades_df.entry_date.isin(w.index)]
         for side, sym, nm in [("LONG", "triangle-up", "OOS long"),
@@ -536,7 +676,9 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                max_leverage, fee, slip, train_window,
                p_min, p_gap, flat_max, agree_min, bacc_min, min_trades,
                skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
-               vp_mode, vp_window, vp_bins, vp_va, vp_ext):
+               vp_mode, vp_window, vp_bins, vp_va, vp_ext,
+               ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
+               ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact):
     try:
         ticker = str(ticker).strip().upper()
         h = int(horizon)
@@ -591,6 +733,18 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         ind_confirm = ind_mode == IND_MODES[1]
         ind_now = int(ind_arr[-1])
 
+        # --- Lorentzian Classification (ML + kernel), tamamen Python'da
+        ldc_on = ldc_mode != LDC_MODES[0]
+        ldc_only = ldc_mode == LDC_MODES[2]
+        ldc_confirm = ldc_mode == LDC_MODES[1]
+        ind_only = ind_only and not ldc_only      # iki "Sadece" modu birlikteyse Lorentzian öncelikli
+        LD = ldc_classify(df, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
+                          use_vol=bool(ldc_use_vol), use_regime=bool(ldc_use_regime),
+                          use_adx=bool(ldc_use_adx), use_kernel=bool(ldc_kernel),
+                          exact=bool(ldc_exact)) if ldc_on else None
+        ldc_arr = LD["state"] if LD else np.zeros(len(df), dtype=int)
+        ldc_now = int(ldc_arr[-1])
+
         # --- K seçimi, kalibrasyon, güncel olasılık
         best_k, k_scores = tune_k(dev_X, dev_y, h)
         cal_n = min(120, max(45, int(len(dev_X)*0.20)))
@@ -614,6 +768,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
             side = 1 if p_up >= p_down else -1
         if ind_only and ind_now != 0 and allow[ind_now]:
             side = ind_now
+        if ldc_only and ldc_now != 0 and allow[ldc_now]:
+            side = ldc_now
         p_side, p_opp = (p_up, p_down) if side == 1 else (p_down, p_up)
 
         imp, scaler = cal_model.named_steps["imputer"], cal_model.named_steps["scale"]
@@ -622,6 +778,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         agreement = float((fit_y.iloc[idx[0]].to_numpy() == side).mean())
         if ind_only:  # indikatör modunda: son 10 mumda yönün sürekliliği
             agreement = float((ind_arr[-10:] == side).mean())
+        if ldc_only:
+            agreement = float((ldc_arr[-10:] == side).mean())
 
         # --- yön bazlı TP/SL optimizasyonu (yalnızca geliştirme verisi)
         current_regime = str(regimes_all.iloc[-1])
@@ -632,6 +790,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
             f_ = list(dev_pos)
             if ind_only or ind_confirm:
                 f_ = [i for i in f_ if ind_arr[i] == s_]
+            if ldc_on:
+                f_ = [i for i in f_ if ldc_arr[i] == s_]
             if vp_on:
                 f_ = [i for i in f_ if vp_arr[i] == s_]
             return f_ if len(f_) >= 35 else dev_pos
@@ -651,6 +811,10 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
         oos_acc = float(accuracy_score(oos_y, oos_pred))
         oos_pos_arr = pos_of(oos_X.index)
+        if ldc_only:  # Lorentzian yönü OOS'ta tahmin yerine geçer
+            oos_pred = ldc_arr[oos_pos_arr]
+            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
+            oos_acc = float(accuracy_score(oos_y, oos_pred))
         if ind_only:  # indikatör yönü OOS'ta tahmin yerine geçer
             oos_pred = ind_arr[oos_pos_arr]
             oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
@@ -665,6 +829,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                 continue
             if vp_on and vp_arr[i] != pred:
                 continue
+            if ldc_confirm and ldc_arr[i] != pred:
+                continue
             if skip_overlap and i <= busy:
                 continue
             sl_p, rr_p = params[pred]
@@ -721,12 +887,14 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         ]
         dname = {1: "LONG ↑", -1: "SHORT ↓", 0: "belirsiz"}
         ind_check = ("İndikatör yönü (ST + UT aynı)", dname[ind_now], "yönle aynı", ind_now == side)
-        if ind_only:
+        if ind_only or ldc_only:
             keep = ("Yön izni", "OOS balanced acc.", "OOS işlem sayısı", "OOS expectancy")
             checks = [c for c in checks if c[0] in keep]
+        if ind_only or ind_confirm:
             checks.insert(1, ind_check)
-        elif ind_confirm:
-            checks.insert(1, ind_check)
+        if ldc_on:
+            checks.insert(1, ("Lorentzian yönü (ML + kernel)", dname[ldc_now], "yönle aynı",
+                              ldc_now == side))
         if vp_on:
             checks.insert(1, ("Volume Profile (POC/VA konumu)", vp_names[int(vp_arr[-1])],
                               "yönle aynı", int(vp_arr[-1]) == side))
@@ -782,6 +950,20 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                    f"uzama sınırı {float(vp_ext):g} ATR."
                    + (" Hacim verisi yok → zaman bazlı profil kullanıldı." if vp_no_vol else "")
                    + (" Mod Kapalı: yalnızca bilgi amaçlı." if not vp_on else ""))
+        if LD is not None:
+            fl = lambda on, arr: "kapalı" if not on else ("✅" if bool(arr[-1]) else "❌")
+            ldc_md = md_table(["Bileşen", "Değer"], [
+                ("Lorentzian yönü (ML + kernel)", dname[ldc_now]),
+                ("ML sinyali (filtreli)", dname[int(LD["signal"][-1])]),
+                ("ML tahmin skoru", f"{int(LD['pred'][-1]):+d} / ±{int(ldc_k)}"),
+                ("Kernel tahmini · eğim", f"{fmt_p(float(LD['yhat'][-1]))} · "
+                                          f"{'↑' if LD['yhat'][-1] > LD['yhat'][-2] else '↓'}"),
+                ("Volatilite / Rejim / ADX filtresi",
+                 f"{fl(ldc_use_vol, LD['vol'])} / {fl(ldc_use_regime, LD['reg'])} / {fl(ldc_use_adx, LD['adx'])}")])
+            ldc_note = (f"{int(ldc_k)} komşu · en fazla {int(ldc_back)} geçmiş mum · kernel "
+                        f"({int(ldc_kern_lb)}, {float(ldc_kern_rw):g}) · rejim eşiği {float(ldc_regime):g}.")
+        else:
+            ldc_md, ldc_note = "_Mod kapalı._", ""
         k_text = " | ".join(f"K={k}: {s:.3f}" for s, k in sorted(k_scores, reverse=True)) or "—"
         overlap_note = ("tek pozisyon (çakışma yok)" if skip_overlap
                         else "çakışan sinyaller bağımsız işlem sayıldı")
@@ -806,6 +988,11 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
 ## İndikatörler — mod: {ind_mode}
 {ind_md}
 
+## Lorentzian Classification — mod: {ldc_mode}
+{ldc_md}
+
+{ldc_note}
+
 ## Volume Profile — mod: {vp_mode}
 {vp_md}
 
@@ -860,7 +1047,8 @@ TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geli
 
         price_fig = price_figure(df, ticker, trades_df, trade_ok, stop, target,
                                  ind=(st_line, st_dir, ut_stop),
-                                 vp=vp if vp_on else None, vp_prof=lp)
+                                 vp=vp if vp_on else None, vp_prof=lp,
+                                 ldc=LD)
         eq_fig = equity_figure(curve, dds) if len(R) else None
         pf_fig = pf_gauge(stats["pf"], stats["n"]) if stats else None
         mc_fig = mc_figure(mc) if mc else None
@@ -876,7 +1064,7 @@ TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geli
             "seri korelasyonunu ve rejim değişimini tam modellemez. Pozisyon hesabı spot miktar "
             "varsayar; CFD lot sözleşmesi, spread, funding, swap, komisyon, minimum lot, marjin ve "
             "broker fiyatı farklı olabilir. Gap ve kayma kaybı planlanan riskin üstüne çıkarabilir. "
-            "Supertrend ve UT Bot, TradingView formüllerinin Python portudur; ATR başlangıcı ve veri kaynağı yüzünden TV değerlerinden küçük sapmalar olabilir. Volume Profile, günlük OHLCV'den (her mumun hacmi high–low aralığına eşit dağıtılarak) yaklaşık hesaplanır; TradingView VPVR'nin alt-zaman dilimi verisiyle birebir aynı olmaz. Canlı hesap öncesi paper trading ve broker bazlı doğrulama zorunludur."
+            "Supertrend ve UT Bot, TradingView formüllerinin Python portudur; ATR başlangıcı ve veri kaynağı yüzünden TV değerlerinden küçük sapmalar olabilir. Lorentzian Classification, jdehorty'nin TradingView göstergesinin Python portudur (ANN komşu seçimi, filtreler ve kernel regresyon); Pine kaynağıyla birebir aynı sonuç vermeyebilir ve yalnızca günlük mumda çalışır. Volume Profile, günlük OHLCV'den (her mumun hacmi high–low aralığına eşit dağıtılarak) yaklaşık hesaplanır; TradingView VPVR'nin alt-zaman dilimi verisiyle birebir aynı olmaz. Canlı hesap öncesi paper trading ve broker bazlı doğrulama zorunludur."
         )
         return (report, prob_figure(p_down, p_flat, p_up), price_fig, eq_fig, pf_fig, mc_fig,
                 top_df, csv_path, disclaimer)
@@ -903,6 +1091,7 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
             side_mode = gr.Radio(SIDE_MODES, value="Long + Short", label="İzin verilen yön")
             ind_mode = gr.Radio(IND_MODES, value="Kapalı", label="İndikatör modu (Supertrend + UT Bot)")
             vp_mode = gr.Radio(VP_MODES, value="Kapalı", label="Volume Profile modu")
+            ldc_mode = gr.Radio(LDC_MODES, value="Kapalı", label="Lorentzian Classification modu")
             train_window = gr.Slider(300, 1500, value=900, step=50, label="Maksimum eğitim penceresi")
         with gr.Column():
             equity = gr.Number(value=10000, label="Hesap büyüklüğü (USD)")
@@ -925,6 +1114,19 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
             st_mult = gr.Slider(1.0, 6.0, value=3.0, step=0.1, label="Supertrend çarpanı")
             ut_key = gr.Slider(0.5, 4.0, value=1.0, step=0.1, label="UT Bot key value")
             ut_period = gr.Slider(5, 30, value=10, step=1, label="UT Bot ATR periyodu")
+        with gr.Row():
+            ldc_k = gr.Slider(1, 30, value=8, step=1, label="Lorentzian komşu sayısı")
+            ldc_back = gr.Slider(300, 3000, value=2000, step=100, label="Lorentzian maks. geçmiş mum")
+            ldc_regime = gr.Slider(-2.0, 2.0, value=-0.1, step=0.1, label="Rejim eşiği")
+        with gr.Row():
+            ldc_kern_lb = gr.Slider(3, 50, value=8, step=1, label="Kernel lookback")
+            ldc_kern_rw = gr.Slider(0.25, 25, value=8, step=0.25, label="Kernel göreli ağırlık")
+        with gr.Row():
+            ldc_use_vol = gr.Checkbox(value=True, label="Volatilite filtresi")
+            ldc_use_regime = gr.Checkbox(value=True, label="Rejim filtresi")
+            ldc_use_adx = gr.Checkbox(value=False, label="ADX filtresi (eşik 20)")
+            ldc_kernel = gr.Checkbox(value=True, label="Kernel ile onayla")
+            ldc_exact = gr.Checkbox(value=True, label="Gerçek en yakın komşu (kapalı: Pine yaklaşık-NN)")
         with gr.Row():
             vp_window = gr.Slider(20, 250, value=60, step=5, label="Volume Profile penceresi (mum)")
             vp_bins = gr.Slider(12, 60, value=24, step=2, label="Fiyat kutusu sayısı")
@@ -958,7 +1160,9 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
                 max_leverage, fee, slip, train_window,
                 p_min, p_gap, flat_max, agree_min, bacc_min, min_trades,
                 skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
-                vp_mode, vp_window, vp_bins, vp_va, vp_ext],
+                vp_mode, vp_window, vp_bins, vp_va, vp_ext,
+                ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
+                ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact],
         outputs=[output, prob_plot, chart, equity_plot, pf_plot, mc_plot, optimization,
                  csv_file, disclaimer],
     )