L04 — Avversione alle perdite e disposizione, misurate sui propri numeri

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, equity, rendimenti
from cvbook.simulazioni import equity_casuali

prezzi = carica("btcusdt").sort("data")["chiusura"].to_numpy()
r = rendimenti(prezzi)

PRENDI_UTILE = 0.10   # ← chiudi quando sei in utile di questa percentuale
                      # PROVA / TRY: 0,05 · 0,10 · 0,50 (vedi esercizi 1 e 2)
SOPPORTA_PERDITA = 0.50  # ← resti dentro finche' la perdita non arriva a questa
                         # PROVA / TRY: 0,10 · 0,50 · 0,70 (vedi esercizi 1 e 2)
COSTO = 0.0012           # ← costo di un GIRO COMPLETO — chiudere e riaprire
                         # PROVA / TRY: 0,0006 · 0,0012 · 0,0025
# NON TOCCARE / DO NOT CHANGE: qui lo 0,12% e' il costo di un giro completo, ed
# e' la convenzione che il libro dichiara fino al capitolo sull'analisi tecnica.
# Addebitarlo due volte per giro — una in uscita e una al rientro — e' la
# convenzione severa, che il libro introduce solo dal cap. 18b in avanti: con
# quella il quaderno chiudeva a 8,46 volte dove il capitolo stampa 9,0.
# Here 0.12% is the cost of a full round trip, the convention the book declares
# up to the technical-analysis chapter. Charging it twice per round trip is the
# stricter convention, introduced only from ch. 18b on.


def con_soglie(p: np.ndarray, su: float, giu: float, costo: float) -> np.ndarray:
    """Chiude quando la posizione tocca una soglia, e rientra il giorno dopo.

    Sono tre le cose che questo comportamento paga rispetto al non far nulla,
    e vale la pena tenerle distinte perche' pesano in modo molto diverso:

    1. il costo del giro completo — uscita piu' rientro — addebitato una volta
       sola, in uscita, secondo la convenzione dichiarata dal capitolo;
    2. il giorno passato fuori dal mercato ad ogni chiusura — ed e' questa la
       voce piu' cara, perche' il capitolo sulla media che mente ha mostrato
       che pochissimi giorni contengono quasi tutto il risultato;
    3. niente altro: nessuna previsione, nessuna scelta di direzione.
    """
    valore = np.empty(len(p))
    valore[0] = 1.0
    ingresso, quota, liquido, dentro = p[0], 1.0 / p[0], 0.0, True

    for i in range(1, len(p)):
        if dentro:
            corrente = quota * p[i]
            variazione = p[i] / ingresso - 1.0
            if variazione >= su or variazione <= -giu:
                liquido = corrente * (1.0 - costo)   # esce: paga il giro intero
                dentro, corrente = False, liquido
            valore[i] = corrente
        else:
            ingresso = p[i]          # rientra il giorno dopo, senza ripagare:
            quota = liquido / p[i]   # il giro e' gia' stato addebitato in uscita
            dentro = True
            valore[i] = quota * p[i]

    # Anche l'ingresso del primo giorno e' un'operazione, e va pagato: sotto
    # sta il compra-e-tieni che lo paga, e le due colonne devono essere
    # confrontabili fino all'ultimo centesimo.
    return valore * (1.0 - costo)


# Anche chi non tocca niente paga il proprio ingresso: e' un'operazione, e il
# metro di confronto non puo' viaggiare gratis mentre l'altro comportamento
# paga. Sono dodici centesimi per mille euro, tutti a favore della tesi.
# Whoever never touches anything still pays for the entry: it is one trade, and
# the benchmark cannot travel for free while the other behaviour pays.
fermo = equity(r) * (1 - COSTO)
nervoso = con_soglie(prezzi, PRENDI_UTILE, SOPPORTA_PERDITA, COSTO)

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.semilogy(fermo, linewidth=1.8, label="compra e non tocca niente")
    ax.semilogy(nervoso, linewidth=1.8, linestyle="--",
                label=f"chiude a +{PRENDI_UTILE:.0%}, sopporta -{SOPPORTA_PERDITA:.0%}")
    ax.set_ylabel("Capitale (scala log)")
    ax.set_xlabel("Giorni")
    ax.legend()
    plt.show()

print(f"chi non ha toccato niente:  {fermo[-1]:6.2f}x   calo massimo {drawdown_massimo(fermo):.1%}")
print(f"chi ha preso i piccoli utili: {nervoso[-1]:6.2f}x   calo massimo {drawdown_massimo(nervoso):.1%}")
print(f"differenza: {nervoso[-1] / fermo[-1] - 1:+.1%}")

CURVATURA = 0.88
AVVERSIONE = 2.25
# NON TOCCARE / DO NOT CHANGE: sono i parametri stimati sperimentalmente dalla
# teoria del prospetto (Kahneman e Tversky), non un valore a piacere — cambiarli
# smetterebbe di rappresentare quella ricerca.
# These are the parameters experimentally estimated by prospect theory
# (Kahneman and Tversky), not an arbitrary value — changing them would stop
# representing that research.

importi = np.linspace(-10_000, 10_000, 400)
# np.where valuta entrambi i rami: si eleva a potenza il valore assoluto e si
# rimette il segno dopo, altrimenti numpy si lamenta delle radici di numeri
# negativi (e ha ragione).
grandezza = np.abs(importi) ** CURVATURA
valore = np.where(importi >= 0, grandezza, -AVVERSIONE * grandezza)

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.plot(importi, valore, linewidth=2)
    ax.axhline(0, linewidth=0.8, color="#8C8C8C")
    ax.axvline(0, linewidth=0.8, color="#8C8C8C")
    ax.set_xlabel("Guadagno o perdita (euro)")
    ax.set_ylabel("Valore percepito (unità arbitrarie)")
    plt.show()

for x in (2_000, 8_000):
    su = x**CURVATURA
    giu = AVVERSIONE * x**CURVATURA
    print(f"{x:6,d} euro:  piacere {su:9.1f}   dolore {giu:9.1f}   rapporto {giu / su:.2f}")

passo_vicino = AVVERSIONE * (2000**CURVATURA)
passo_lontano = AVVERSIONE * (10000**CURVATURA - 8000**CURVATURA)
print(f"\ndolore nel passare da 0 a -2.000:      {passo_vicino:8.1f}")
print(f"dolore nel passare da -8.000 a -10.000: {passo_lontano:8.1f}")
print("È il motivo per cui, dopo una perdita gia' grande, rischiare ancora "
      "costa pochissimo in termini di sofferenza attesa.")

rng = np.random.default_rng(seed_for("lab-bias-indovina"))
# NON TOCCARE / DO NOT CHANGE: scrivi la tua risposta PRIMA di eseguire la
# cella successiva. Cambiare il seme dopo aver sbagliato per ottenere un
# disegno più facile vanificherebbe l'esercizio, non lo migliorerebbe.
# Write down your answer BEFORE running the next cell. Changing the seed
# after getting it wrong, to get an easier draw, would defeat the exercise,
# not improve it.
VANTAGGI = rng.permutation([0.0, 0.0, 0.0, 0.0005, 0.0005, 0.0])

with avvio.figura("schermo"):
    fig, assi = plt.subplots(2, 3, figsize=(11, 5))
    curve = []
    for k, ax in enumerate(assi.flat):
        c = equity_casuali(1, 400, rendimento_atteso=VANTAGGI[k],
                           volatilita_periodo=0.02, rng=rng)[0]
        curve.append(c)
        ax.plot(c * 100, linewidth=1.4)
        ax.axhline(100, linestyle=":", linewidth=0.8)
        ax.set_title(f"serie {k + 1}", fontsize=10)
        ax.set_xticks([])
    plt.show()

print("vantaggio reale per operazione:")
for k, v in enumerate(VANTAGGI):
    print(f"  serie {k + 1}: {v:.4%}  →  capitale finale {curve[k][-1]:.2f}x")
print("\nSe le due con vantaggio non sono quelle che avevi indicato, non e' un "
      "tuo limite: 400 osservazioni non bastano a distinguerle, e il capitolo "
      "sulla potenza statistica dice quante ne servirebbero.")