L16 — Sei regole da manuale misurate insieme, con i tre controlli

import matplotlib.pyplot as plt
import numpy as np

from cvbook import seed_for
from cvbook.dati import carica
from cvbook.metriche import drawdown_massimo
from cvbook.regole import CATALOGO, compra_e_tieni, esegui, rottura

SERIE = "btcusdt"   # ← PROVA / TRY: "ethusdt" · "solusdt" (le tre preparate nel setup)
COSTO = 0.0012      # ← il tuo costo per operazione
                    # PROVA / TRY: raddoppialo (vedi esercizio 1)

prezzi = carica(SERIE).sort("data")["chiusura"].to_numpy()

riferimento = esegui(prezzi, compra_e_tieni(prezzi), costo=COSTO)

righe = []
for nome, regola in CATALOGO.items():
    e = esegui(prezzi, regola(prezzi), costo=COSTO)
    righe.append((nome, e["finale"], e["finale_lordo"], e["operazioni"],
                  e["esposizione"], drawdown_massimo(e["curva"])))
righe.sort(key=lambda x: x[1])

print(f"{SERIE}, costi {COSTO:.2%} per operazione\n")
print(f"{'regola':>22s} {'netto':>9s} {'lordo':>9s} {'oper.':>7s} "
      f"{'dentro':>8s} {'calo max':>10s}")
for nome, netto, lordo, op, esp, dd in righe:
    print(f"{nome:>22s} {netto:8.2f}x {lordo:8.2f}x {op:7.0f} {esp:8.0%} {dd:10.1%}")
print(f"{'compra e tieni':>22s} {riferimento['finale']:8.2f}x "
      f"{riferimento['finale_lordo']:8.2f}x {riferimento['operazioni']:7.0f} "
      f"{riferimento['esposizione']:8.0%} {drawdown_massimo(riferimento['curva']):10.1%}")

with avvio.figura("schermo"):
    fig, ax = plt.subplots(figsize=(9, 4.5))
    y = np.arange(len(righe))
    ax.barh(y, [r[1] for r in righe])
    ax.axvline(riferimento["finale"], linewidth=2, linestyle="--", color="black")
    ax.annotate(f"compra e tieni: {riferimento['finale']:.1f}x",
                xy=(riferimento["finale"], len(righe) - 0.4),
                xytext=(6, 0), textcoords="offset points", va="center")
    ax.set_yticks(y)
    ax.set_yticklabels([r[0] for r in righe])
    ax.set_xscale("log")
    ax.set_xlabel("Capitale finale, per ogni euro investito (scala log)")
    plt.show()

battono = sum(1 for r in righe if r[1] > riferimento["finale"])
print(f"\n{battono} regole su {len(righe)} hanno battuto il non far niente.")

print(f"{'regola':>22s} " + "".join(f"{c:>11.2%}" for c in (0.0, 0.0006, 0.0012, 0.0025, 0.005)))
for nome, regola in CATALOGO.items():
    valori = "".join(f"{esegui(prezzi, regola(prezzi), costo=c)['finale']:10.2f}x"
                     for c in (0.0, 0.0006, 0.0012, 0.0025, 0.005))
    print(f"{nome:>22s} {valori}")
# Anche il compra-e-tieni ha un'operazione — il proprio ingresso — quindi la
# sua riga cambia con la colonna, di poco ma cambia. Stamparla costante era
# comodo e falso: diceva che il metro di confronto non paga i costi.
print(f"{'compra e tieni':>22s} " +
      "".join(f"{esegui(prezzi, compra_e_tieni(prezzi), costo=c)['finale']:10.2f}x"
              for c in (0.0, 0.0006, 0.0012, 0.0025, 0.005)))

print("\n«Quale regola e' migliore» dipende da quanto paghi. Chi pubblica un "
      "backtest senza costi non ha mentito su nessun numero: ha omesso una voce, "
      "e l'omissione puo' invertire la conclusione.")

FINESTRE = np.arange(5, 121, 5)  # PROVA / TRY: allarga o restringi il passo
griglia = np.array([esegui(prezzi, rottura(prezzi, int(f)), costo=COSTO)["finale"]
                    for f in FINESTRE])

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.plot(FINESTRE, griglia, marker="o", linewidth=2)
    ax.axhline(riferimento["finale"], linestyle="--", linewidth=1.5, color="black",
               label="compra e tieni")
    ax.set_yscale("log")
    ax.set_xlabel("Finestra della rottura (giorni)")
    ax.set_ylabel("Capitale finale (volte, scala log)")
    ax.legend()
    plt.show()

print(f"valori che battono il compra-e-tieni: {int((griglia > riferimento['finale']).sum())} "
      f"su {len(griglia)}")
print(f"mediana della griglia: {np.median(griglia):.2f}x")

N_CASUALI = 1000  # PROVA / TRY: 200 (veloce) · 1000 · 10000 (percentile più preciso)
SCELTA = 20


def posizione_casuale(n: int, n_operazioni: int, rng) -> np.ndarray:
    pos = np.zeros(n)
    punti = np.sort(rng.choice(n - 1, size=n_operazioni, replace=False))
    stato, precedente = 0.0, 0
    for i in punti:
        pos[precedente:i] = stato
        stato, precedente = 1.0 - stato, i
    pos[precedente:] = stato
    return pos


scelta = esegui(prezzi, rottura(prezzi, SCELTA), costo=COSTO)
n_op = int(scelta["operazioni"])
rng = np.random.default_rng(seed_for("tecnica-verifica"))
# NON TOCCARE / DO NOT CHANGE: è il seme della figura stampata nel capitolo.
# Con quello — stesse mille posizioni casuali, stesse operazioni, stessi costi
# — questa cella ridisegna l'istogramma del libro e stampa il suo percentile.
# Con un seme qualunque il quaderno resta corretto ma risponde 98,9 dove la
# pagina dice 98: due numeri per la stessa domanda, ed è la cosa che questo
# libro promette di non fare.
# This is the seed of the figure printed in the chapter.
casuali = np.array([
    esegui(prezzi, posizione_casuale(len(prezzi), n_op, rng), costo=COSTO)["finale"]
    for _ in range(N_CASUALI)
])
percentile = float((casuali < scelta["finale"]).mean() * 100)

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.hist(casuali, bins=50)
    ax.axvline(scelta["finale"], linewidth=2.5, color="black")
    ax.set_xscale("log")
    ax.set_xlabel("Capitale finale (volte, scala log)")
    ax.set_ylabel(f"Su {N_CASUALI} posizioni casuali")
    ax.set_title(f"La regola sta al {percentile:.0f}esimo percentile")
    plt.show()

print(f"la regola: {scelta['finale']:.2f}x con {n_op} operazioni")
print(f"mediana delle casuali: {np.median(casuali):.2f}x")
print(f"percentile: {percentile:.1f}")

regole_provate = len(CATALOGO)
parametri_provati = len(FINESTRE)
tentativi = regole_provate + parametri_provati

p_singolo = 1 - percentile / 100
print(f"regole provate: {regole_provate}")
print(f"valori del parametro provati: {parametri_provati}")
print(f"tentativi complessivi (stima prudente): {tentativi}\n")
print(f"probabilita' che UN tentativo raggiunga questo percentile per caso: {p_singolo:.1%}")
print(f"probabilita' che almeno uno su {tentativi} lo faccia: "
      f"{1 - (1 - p_singolo) ** tentativi:.1%}")
print("\nI tentativi non sono del tutto indipendenti — finestre vicine danno "
      "risultati simili — quindi questa stima e' pessimistica. Ma il punto resta: "
      "un percentile, dopo trenta tentativi, non e' piu' quel percentile.")

for altro in ("btcusdt", "ethusdt", "solusdt"):
    p = carica(altro).sort("data")["chiusura"].to_numpy()
    r = esegui(p, rottura(p, SCELTA), costo=COSTO)
    b = esegui(p, compra_e_tieni(p), costo=COSTO)
    print(f"{altro:>10s}: regola {r['finale']:8.2f}x   compra e tieni {b['finale']:8.2f}x   "
          f"rapporto {r['finale'] / b['finale']:5.2f}")

print("\nTre conferme? No. Il Lab 8 ha mostrato che questi tre mercati contengono "
      "poco piu' di UNA scommessa: una sola componente ne spiega quasi l'ottanta "
      "per cento dei movimenti. Un metodo che funziona sul fattore comune "
      "funziona su tutti e tre — non perche' sia stato confermato tre volte, ma "
      "perche' e' stato confermato una volta e conteggiato tre.")