In questo articolo descriviamo come costruire un indicatore di Swing con Tradingview da applicare alle strategie di trading algoritmico. Gli swing nei movimenti dei prezzi possono fornire punti di ingresso logici sia per strategie mean-reverting che per le strategie di trend following. Gli swing segnalano che il prezzo si è invertito rispetto a un significativo movimento o ritracciamento e che il prezzo potrebbe continuare a muoversi nella direzione opposta. Se stiamo cercando di entrare alla fine di un ritracciamento o di un trend, uno swing può darci una conferma che stiamo operando nella giusta direzione.
Non è tutto così semplice, perchè rilevare uno swing è possibile solo molto tempo dopo che lo swing è accaduto. Inoltre, il ritardo nel rilevamento dello swing è di gran lunga maggiore rispetto alla maggior parte degli indicatori lagging. Maggiore è l’affidabilità che desideriamo nel confermare uno swing, maggiore sarà il ritardo nella rilevazione e, quindi, dobbiamo ritardare l’entrata di un trade.
In questo articolo descriviamo come costruire un indicatore di swing con Tradingview da applicare alle strategie di trading algoritmico, vediamo gli scenari dove può essere usato correttamente, e mostriamo alcuni esempi dove può causare criticità.
Indicatore di Swing con Tradingview
L’indicatore consente agli utenti di “analizzare” una candela storica recente per rilevare se si tratta di un punto di swing. Funziona inserendo un numero per selezionare quale candela storica vogliamo controllare. L’indicatore controlla quindi tutte le candele successive fino alla candela corrente. Controlla anche la stessa quantità di candele prima della candela selezionata. Se la candela analizzata corrisponde al minimo più basso o al massimo più alto dell’intervallo usato, allora possiamo dire che la candela è un punto di swing.
Codice indicatore oscillazione
//@version=3
study("Swing Indicator", overlay=true)
////////////////////////////////////////////////////////////////////////////////
// Swing Dectection Indicator
////////////////////////////////////////////////////////////////////////////////
barsback = input(7, title='Bars back to check for a swing')
showsig = input(false, title='Show Signal Markers')
swing_detection(index)=>
swing_high = false
swing_low = false
start = (index*2) - 1 // -1 so we have an even number of
swing_point_high = high[index]
swing_point_low = low[index]
//Swing di Massimi
for i = 0 to start
swing_high := true
if i < index
if high[i] > swing_point_high
swing_high := false
break
// Fare separatamente i controlli prima del pivot e dopo perché possiamo ottenere
// due massimo dello stesso valore di fila. Notare la differenza > e >=
if i > index
if high[i] >= swing_point_high
swing_high := false
break
//Swing di Minimi
for i = 0 to start
swing_low := true
if i < index
if low[i] < swing_point_low
swing_low := false
break
// Fare separatamente i controlli prima del pivot e dopo perché possiamo ottenere
// due minimi dello stesso valore di fila. Notare la differenza > e >=
if i > index
if low[i] <= swing_point_low
swing_low := false
break
[swing_high, swing_low]
// Controllo per uno swing
[swing_high, swing_low] = swing_detection(barsback)
// Graifco
plotshape(swing_high, style=shape.arrowdown, location=location.abovebar, color=red, text='SH', offset=-barsback)
plotshape(swing_low, style=shape.arrowup, location=location.belowbar, color=green, text='SL', offset=-barsback)
plotshape(showsig ? swing_high : na, style=shape.arrowdown, location=location.abovebar, color=blue, text='Sig')
plotshape(showsig ? swing_low : na, style=shape.arrowup, location=location.belowbar, color=blue, text='Sig')
Commento del codice
Tutta la logica del rilevamento dello swing è implementata in un’unica grande funzione swing_dectection(). Questa funzione scorre semplicemente l’intero range di candele sia prima che dopo la candela analizzata. Se in qualsiasi momento un’altra candela ha un massimo più alto o un minimo più basso, il ciclo si interrompe e si restituisce false. Al contrario, se il ciclo arriva alla fine senza un break, abbiamo uno swing e si restituisce true.
Per ulteriori informazioni su come scrivere cicli e funzioni, possiamo legare i seguenti tutorial:
Successivamente, quando si visualizza lo swing nel grafico, è necessario utilizzare il parametro offset. Questo perché lo script valuta true la candela corrente ma in realtà stiamo analizzando una candela storica. Pertanto, dobbiamo compensare il grafico in base al valore barsback di input in modo che lo swing sia contrassegnato correttamente.
Infine, tracciamo un marcatore sulla barra corrente perchè questa è la prima candela dove il segnale è confermato e come tale non potremmo agire sullo swing prima di essa. Questo indicatore può essere usato per segnalare entrate e avvisi.
A proposito del lagging
In precedenza, abbiamo menzionato il lagging, o ritardo. Più guardiamo indietro, maggiore è il ritardo. Questa può essere una benedizione così come una maledizione a seconda dei nostri obiettivi. Da un lato, maggiore è il ritardo consentito, maggiore è la fiducia che lo swing è stato reale. D’altra parte, possiamo avere così tanto ritardo che il movimento di inversione o ritracciamento si è già completato quando siamo pronti ad entrare. Diamo un’occhiata.
Nel primo esempio abbiamo un grafico che mostra l’indicatore con le impostazioni default.
A prima vista, sembra fantastico. Identifica bene ciascuno degli swing massimi e minimi all’interno dell’intervallo. Tuttavia, se attiviamo l’indicatore di segnale, appare così:
Come possiamo vedere, il movimento del prezzo è quasi terminato prima che possiamo rilevare lo swing da dove il movimento si è generato. Pertanto sappiamo che le impostazioni di default non sono adatte a mercati con piccoli swing.
Se poi riduciamo il ritardo (riducendo il numero di candele di looback), possiamo entrare prima ma in questo caso aumentano il numero di falsi segnali:
Anche questo caso non è l’ideale, ma è il prezzo che dobbiamo pagare per essere in anticipo! In questo scenario, è meglio non agire su ogni swing. Invece, dobbiamo concentrati su gli swing che sono vicini ai livelli noti di supporto/resistenza o che confermano i segnali di altri indicatori.
Mercati in trend
Se stiamo eseguendo una strategia long-only e proviamo il “buy the dip”, possiamo disattivare il tracciamento degli swing brevi e ridurre il barsback per trovare alcune belle entrate long su un titolo in trend.
Analisi tecnica
Nell’ultimo esempio, usiamo l’indicatore per aiutare altre analisi tecniche. Ad esempio possiamo facilmente individuare la divergenza tra un RSI e l’azione del prezzo.
Miglioramenti ed Estensioni
Un’estensione per migliorare l’indicatore di Swing con Tradingview che viene subito in mente è quella di aggiungere un secondo input che consente di specificare quante candele controllare prima della candela analizzata. Ciò consentirebbe un rilevamento asimmetrico in cui controlliamo meno candele dopo lo swing rispetto a prima. Questa soluzione ci permetterebbe di entrare ancora presto pur mantenendo una certa fiducia che si stia formando uno swing.
Per finire, vale la pena sottolineare che gli swing possono aiutarci a identificare i livelli di supporto/resistenza e costituire la base per il rilevamento della trendline. Pertanto, anche se non si vede alcun valore nell’utilizzo del codice nella sua forma attuale, potrebbe comunque costituire un importante elemento costitutivo per altri indicatori più complessi.
Codice completo
In questo articolo abbiamo descritto come costruire un indicatore di Swing con Tradingview da applicare alle strategie di trading algoritmico. Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/TradingView
