Ci sono alcune strategie di trading dove riceviamo un segnale ma non desideriamo entrare immediatamente in posizione. Un classico esempio è attendere la conferma di un segnale prima di entrare in una posizione. In questo articolo descriviamo come gestire la finestra di un segnale con Tradingview per il trading algoritmico. In particolare come aprire una finestra, tenerla aperta e chiuderla in modo appropriato quando la finestra scade o entriamo in una posizione.
La finestra
Aprire una finestra è facile come entrare in una posizione. Dobbiamo solo controllare se le condizioni per aprirla sono true. La parte più complicata è tenerla aperta e poi chiuderla correttamente quando la finestra non è più valida/necessaria. Otteniamo questo obiettivo con un operatore condizionale ternario.
Punti di attenzione
Questo articolo potrebbe essere un pò complesso per i neofiti. Presuppone un certo livello di conoscenza del linguaggio pine-script. Per esempio, descriviamo solo il codice relativo all’apertura e alla chiusura di una finestra. Se si vuole approfondire il linguaggio pine script è possibile leggere gli altri articoli su Tradingview.
Introduzione
Per dare un contesto alla finestra, è necessaria una piccola introduzione alla strategia. Il seguente codice di esempio implementa una grezza strategia di breakout. Prevediamo di entrare in una posizione solo dopo che il prezzo ha ritracciato di un determinato importo E poi è rimbalzato per continuare il trend rialzista/ribassista. Inoltre, questo deve avvenire entro un certo limite di tempo dopo un pivot. La logica dietro il limite di tempo è che un rapido recupero da un ritracciamento di buone dimensioni potrebbe indicare un forte sentiment.
Per raggiungere questo obiettivo, il codice deve essere in grado di:
- Identificare i pivot/swing del prezzo
- Tenere traccia del valore di ritracciamento del prezzo dallo swing minimo/massimo
- Aprire una finestra se il prezzo ritraccia del x% o più
- Catturare una rottura sopra/sotto lo swing massimo/minimo.
- Catturare una rottura entro un determinato numero di barre altrimenti chiudere la finestra.
Nota: questo codice non è destinato per essere usato come strategia a sé stante. Non implementa nessuna strategia di uscita, gestione della posizione o dimensionamento. Va semplicemente long e short e indietro, invertendosi al segnale opposto. In quanto tale, questo esempio deve essere considerato solo come un esercizio.
Gestire la finestra di un segnale con Tradingview
//@version=3
strategy("Window Example", overlay=true)
FromYear = input(defval = 2018, title = "From Year", minval = 2017)
FromMonth = input(defval = 1, title = "From Month", minval = 1, maxval = 12)
FromDay = input(defval = 1, title = "From Day", minval = 1, maxval = 31)
ToYear = input(defval = 9999, title = "To Year", minval = 2017)
ToMonth = input(defval = 1, title = "To Month", minval = 1, maxval = 12)
ToDay = input(defval = 1, title = "To Day", minval = 1, maxval = 31)
start = timestamp(FromYear, FromMonth, FromDay, 00, 00) // inizio backtest
finish = timestamp(ToYear, ToMonth, ToDay, 23, 59) // fine backtest
trade_window = time >= start and time <= finish ? true : false // crea la funzione "all'interno della finestra temporale"
left_bars = input(10, title='Pivot Detection: Left Bars')
right_bars = input(3, title='Pivot Detection: Right Bars')
min_retracement = input(0.5, type=float, title='Min Retracement from pivot')/100
breakout_limit = input(50, title='Breakout Window: Max bars from pivot to breakout')
// Ottenere gli swing più recenti e i loro valori
pivot_high = pivothigh(high, left_bars,right_bars)
pivot_low = pivotlow(low, left_bars, right_bars)
pivot_high_value = valuewhen(pivot_high, high[right_bars], 0)
pivot_low_value = valuewhen(pivot_low, low[right_bars], 0)
// Abbiamo bisogno di verificare se il pivot massimo o il pivot minimo sono attivati per primo.
// perchè non vogliamo attivati in una finestra short quando stiamo cercando un setup long.
since_pivot_high = barssince(pivot_high)
since_pivot_low = barssince(pivot_low)
// Calcolo del ritracciamento dal massimo/minimo
// long_retracement = since_pivot_high < since_pivot_low ? (close - pivot_high_value)/pivot_high_value : na
// short_retracement = since_pivot_low < since_pivot_high ? (close - pivot_low_value)/pivot_low_value : na
long_retracement = since_pivot_high < since_pivot_low ? (close - pivot_high_value)/pivot_high_value : na
short_retracement = since_pivot_low < since_pivot_high ? (close - pivot_low_value)/pivot_low_value : na
// Aprire e Chiudere la finistra
// Chiudere quando:
// - una nuova finestra è aperta
// - un nuovo pivot è individuato (reset)
// - oltrepassare il limite di breakout
buy_window = false
sell_window = false
buy_window :=
strategy.position_size > 0 ? false :
pivot_high ? false :
since_pivot_high > breakout_limit ? false:
long_retracement <= -min_retracement ? true : buy_window[1]
sell_window :=
strategy.position_size < 0 ? false :
pivot_low ? false :
since_pivot_low > breakout_limit ? false:
short_retracement >= min_retracement ? true : sell_window[1]
// Entrate
longCondition = close > pivot_high_value and buy_window and trade_window
if (longCondition)
strategy.entry("Long", strategy.long)
shortCondition = close < pivot_low_value and sell_window and trade_window
if (shortCondition)
strategy.entry("Short", strategy.short)
plotshape(pivot_high, style=shape.arrowdown, location=location.abovebar, color=purple, title='Pivot High', offset=-right_bars)
plotshape(pivot_low, style=shape.arrowup, location=location.belowbar, color=purple, title='Pivot Low', offset=-right_bars)
bgcolor(buy_window and sell_window ? orange : buy_window ? lime : sell_window ? red : na, transp=80)
position_color = strategy.position_size > 0 ? green : strategy.position_size < 0 ? red : silver
plotshape(true, style=shape.circle, location=location.bottom, color=position_color, title='Position Indicator')
// Grafici Test
//plot(long_retracement, style=linebr)
//plot(short_retracement, color=red, style=linebr)
Commento al codice
La parte fondamentale del codice che si concentra sull’apertura e la chiusura della finestra è contenuta nelle seguenti righe:
buy_window = false
sell_window = false
buy_window :=
strategy.position_size > 0 ? false :
pivot_high ? false :
since_pivot_high > breakout_limit ? false:
long_retracement <= -min_retracement ? true : buy_window[1]
sell_window :=
strategy.position_size < 0 ? false :
pivot_low ? false :
since_pivot_low > breakout_limit ? false:
short_retracement >= min_retracement ? true : sell_window[1]
Poiché l’esempio usa la versione 3 di pinescript, per iniziare dobbiamo dichiarare buy_window e sell_window come false. In questo modo possiamo richiamarle nelle righie successive, ad esempio buy_window[1].
Successivamente, implementiamo la logica della finestra tramite l’operatore condizionale ternario menzionato all’inizio di questo articolo. Dato che un operatore condizionale ternario assume il valore della prima condizione vera, è necessario creare controlli di condizione nell’ordine corretto. In questo caso, mettiamo prima tutto quello che dovrebbe chiudere la finestra.
Ad esempio, usando buy_window per prima cosa controlliamo se siamo in una posizione long. In questo caso chiudiamo la finestra long perchè non è più necessaria. Questo è il motivo per cui, guardando i grafici potrebbe non esserci una finestra aperta quando siamo già entrati in un operazione. Per aiutare a verificare questi casi, tracciamo alcuni cerchi nella parte inferiore del grafico per segnalare se la strategia è in una posizione long, short o è flat.
Successivamente, verifichiamo se abbiamo un nuovo pivot. In caso affermativo, resettiamo la finestra perché abbiamo nuovi livelli di misurazione del breakout e di ritracciamento. In questo esempio i livelli sono calcolati dal pivot più recente.
L’ultimo controllo di chiusura che effettuiamo prima di prendere in considerazione l’apertura della finestra è verificare se siamo all’interno del limite di tempo di breakout. In caso contrario, chiudiamo di nuovo la finestra!
Se nessuno di questi casi è verso, allora controlliamo per verificare se il livello di ritracciamento è stato raggiunto (la percentuale di movimento del prezzo dal pivot). In questo caso abbiamo le condizioni per aprire la finestra. Successivamente, la finestra dovrebbe rimanere aperta fino a quando non viene soddisfatta una delle condizioni di chiusura. Il motivo è dovuto al valore assegnato alla finestra quando NESSUNA delle condizioni sopra descritte è soddisfatta. Quando nessuna condizione è soddisfatta (aperta o chiusa), passiamo semplicemente il valore della barra precedente, ad es buy_window[1]. Quindi se la finestra era aperta resta aperta, se era chiusa resta chiusa!
Il grafico
Dopo avere caricato ed eseguito il codice, otteniamo un grafico simile al seguente
Codice completo
In questo articolo abbiamo descritto come gestire la finestra di un segnale con Tradingview per il trading algoritmico. Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/TradingView
