In questo articolo descriviamo come creare trend line con Tradingview, tramite un esempio completamente funzionante e analizzando la logica del codice.
Le trend line possono essere complicate da implementare con pine script. Non solo richiedono un po’ più di matematica di quella che normalmente sia abituati ad usare, ma richiedono di usare anche alcune tecniche avanzate di pine script come la creazione di funzioni. Il codice può essere usato per creare una strategia che si basa sulle trend line per i setup di entrata e uscita.
La Matematica
Per usare il codice descritto in questo articolo non è necessario comprendere appieno la matematica che si applica per determinare una trend line. Dobbiamo solamente capire il funzionamento di ogni riga e quindi copiare e incollare il codice.
Dobbiamo comunque descrivere in dettaglio i concetti matematici alla base delle trend line. Se non ti interessa la matematica, puoi saltare direttamente alla sezione del codice. Quindi leggi la prima parte del commento per avere una panoramica generale della logica del codice.
L’obiettivo principale è calcolare il prezzo di un trend line in qualsiasi momento. A tale scopo dobbiamo calcolare la velocità con cui cambia la pendenza del trend tra due punti nel tempo. Quindi usiamo la pendenza per calcolare i livelli di trend in qualsiasi momento. I due “punti nel tempo” sono i prezzi e le date che prendiamo dal grafico dove il prezzo ha uno swing significativo.
La seguente equazione permette di calcolare il prossimo valore di una trend line.
y=mx+b
Dove:
- y = prezzo
- m = pendenza
- x = data/orario
- b = intercetta di y
Da notare che il prezzo e le date dei due “punti temporali” non permette di calcolare la y-intercept. Questa è la parte più critica della formula. La maggior parte dei tutorial online presumono che possiamo vedere graficamente il valore y-intercept, che corrisponde al valore della linea quando attraversa l’asse y cioè il x è pari a 0. In questo modo:
Su un grafico dei prezzi non abbiamo mai il y-intercept. Per aggirare questo problema, dobbiamo capovolgere un po’ l’equazione.
y=mx+b
Diventa
b = y – m*x
Potresti pensare: “Aspetta! Non ho ancora Y, è quello che sto cercando di ottenere! Quindi come posso risolvere questa equazione?”. Bene, quando proviamo a calcolare b, possiamo usare i valori y e x che corrisponde al punto di swing più recente della trend line. Vedremo nel dettaglio questo concetto nel seguente codice di esempio…
Dopo aver calcolato il y-intercept (o b come è definito nell’equazione) il resto è molto semplice.
Ulteriori letture: https://www.mathplanet.com/education/algebra-1/formulating-linear-equations/writing-linear-equations-using-the-slope-intercept-form
Creare una trend line con Tradingview
//@version=4
study("Trendlines", shorttitle='BTL', overlay=true)
leftbars = input(100, minval=1, title='Pivot Detection: Left Bars')
rightbars = input(15, minval=1, title='Pivot Detection: Right Bars')
plotpivots = input(true, title='Plot Pivots')
// Punti Pivot
ph = pivothigh(high, leftbars, rightbars)
pl = pivotlow(low, leftbars, rightbars)
phv1 = valuewhen(ph, high[rightbars], 0)
phb1 = valuewhen(ph, bar_index[rightbars], 0)
phv2 = valuewhen(ph, high[rightbars], 1)
phb2 = valuewhen(ph, bar_index[rightbars], 1)
plv1 = valuewhen(pl, low[rightbars], 0)
plb1 = valuewhen(pl, bar_index[rightbars], 0)
plv2 = valuewhen(pl, low[rightbars], 1)
plb2 = valuewhen(pl, bar_index[rightbars], 1)
plotshape(ph, style=shape.circle, location=location.abovebar, color=color.orange, title='Pivot High', offset=-rightbars)
plotshape(pl, style=shape.circle, location=location.belowbar, color=color.blue, title='Pivot Low', offset=-rightbars)
plot(ph ? high[rightbars] : na, color=color.orange, offset=-rightbars)
plot(pl ? low[rightbars] : na, color=color.purple, offset=-rightbars)
// TRENDLINE
// --------------
get_slope(x1,x2,y1,y2)=>
m = (y2-y1)/(x2-x1)
get_y_intercept(m, x1, y1)=>
b=y1-m*x1
get_y(m, b, ts)=>
y = m * ts + b
int res_x1 = na
float res_y1 = na
int res_x2 = na
float res_y2 = na
int sup_x1 = na
float sup_y1 = na
int sup_x2 = na
float sup_y2 = na
// Resistenze
res_x1 := ph ? phb1 : res_x1[1]
res_y1 := ph ? phv1 : res_y1[1]
res_x2 := ph ? phb2 : res_x2[1]
res_y2 := ph ? phv2 : res_y2[1]
res_m = get_slope(res_x1,res_x2,res_y1,res_y2)
res_b = get_y_intercept(res_m, res_x1, res_y1)
res_y = get_y(res_m, res_b, bar_index)
// Supporti
sup_x1 := pl ? plb1 : sup_x1[1]
sup_y1 := pl ? plv1 : sup_y1[1]
sup_x2 := pl ? plb2 : sup_x2[1]
sup_y2 := pl ? plv2 : sup_y2[1]
sup_m = get_slope(sup_x1,sup_x2,sup_y1,sup_y2)
sup_b = get_y_intercept(sup_m, sup_x1, sup_y1)
sup_y = get_y(sup_m, sup_b, bar_index)
// plot(line.get_y2(line1))
plot(res_y, color=color.red, title='Resistance Trendline', linewidth=2, style=plot.style_circles)
plot(sup_y, color=color.lime, title='Support Trendline', linewidth=2, style=plot.style_circles)
if ph
line.new(phb1,phv1, bar_index, res_y, style=line.style_dashed, color=color.blue)
if pl
line.new(plb1,plv1, bar_index, sup_y, style=line.style_dashed, color=color.blue)
// Breakout
long_break = crossover(close, res_y)
short_break = crossunder(close, sup_y)
plotshape(long_break, style=shape.triangleup, color=color.green, size=size.tiny, location=location.belowbar, title='Long Break')
plotshape(short_break, style=shape.triangledown, color=color.red, size=size.tiny, location=location.abovebar, title='Short Break')
alertcondition(long_break, title='Long Breakout')
alertcondition(short_break, title='Short Breakout')
Commento al codice
Iniziamo con una descrizione generale dell’indicatore. L’indicatore prevede la visualizzazione di due trend line in un dato momento, una trend line di resistenza e una trend line di supporto. La resistenza è mostrata con cerchi rossi ed è creata unendo insieme i massimi di swing. Il supporto è creato unendo i minimi di swing.
Dato che abbiamo bisogno degli swing per tracciare il trend, il codice implementa la logica per individuare gli swing. Prevediamo dei parametri per modificare la frequenza con cui vengono rilevate nuove trend line. Affidarsi agli swing significa introdurre un ritardo nel rilevare il trend secondo la configurazione prevista per individuare lo swing. Maggiore è il valore impostato in rightbars, maggiore è il ritardo per rilevare un trend. Allo stesso tempo aumenta la qualità dei punti pivot individuati. Dobbiamo quindi prevedere un compromesso e decidere quali sono le impostazioni migliori per la specifica strategia e mercato.
Anatomia della trend line
Una singola trend line è composta da più componenti.
- Punti Pivot: contrassegnati da cerchi blu o arancioni. Ci sono due pivot per trend.
- Linee arancioni/viola: collegano tutti i punti pivot. Queste linee possono leggermente cambiare direzione ogni volta che si individua un nuovo pivot (appaiono nuovi cerchi).
- Linee circolari verdi/rosse: mostrano la trend line dal primo momento che si individua un nuovo trend.
- Linee tratteggiate blu: uniscono le linee circolari viola e verde/rosse in modo da poter vedere la trend line completa.
Nota: le linee tratteggiate blu usano le funzioni di disegno di pine script. Esiste un limite al numero di linee che possono essere posizionate su un grafico. Quando il limite è raggiunto, si rimuove la linea più vecchia in modo da poter tracciare la più recente. In questo modo quando rileviamo molti trend e scorriamo indietro nel tempo, ad un certo punto le linee blu tratteggiate scompaiono!
Funzioni della trend line
Analizzando in dettaglio il codice, abbiamo 3 principali funzioni che forniscono i valori corretti per generare le linee di trend. Queste sono:
// TRENDLINE
// --------------
get_slope(x1,x2,y1,y2)=>
m = (y2-y1)/(x2-x1)
get_y_intercept(m, x1, y1)=>
b=y1-m*x1
get_y(m, b, ts)=>
y = m * ts + b
E’ sufficiente ricavare i prezzi dei pivot e i numeri delle barre e passarli alle funzioni. La funzione get_slope() usa i dati degli ultimi due pivot e restituisce m (la pendenza) che è usata per ottenere il y-intercept. La funzioneget_y_intercept restituisce l’intercetta b (il y-intercept) che è usata per calcolare il valore y tramite la funzione get_y. Questo rappresenta il prossimo valore atteso della trend line ed è calcolato a partire da m e b insieme al numero della barra corrente tramite il bar_index. In effetti, possiamo usare questa funzione per calcolare dove si troverebbe la linea in un dato momento sostituendo bar_index con qualsiasi numero di barra passata o futura.
Ulteriori sviluppi
Questo codice può essere modificato ed integrato in molti modi. Ad esempio si può provare a sostituire il rilevamento dei pivot con un altro metodo per rilevare alcuni punti di ancoraggio per la trend line. In alternativa, si può incorporare questo codice come parte di una strategia.
Codice completo
In questo articolo abbiamo descritto come creare trend line con Tradingview,. Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/TradingView
