In questo articolo descriviamo come gestire le variabili con Tradingview per memorizzare i valori o informazioni e recuperarli in un secondo momento. Questo articolo vuole rispondere ad un frequente problema quando sviluppiamo strategie con pinescript per il trading algoritmico. Ad esempio, supponiamo di avere la seguente necessità:
“Quando apro una posizione voglio memorizzare il valore di un indicatore in quel momento, per poi usarlo con le candele successive.”
E’ un’esigenza molto frequente. Accedere ai valori di una variabile in un secondo momento è utile per numerose applicazioni. Possiamo usarli per monitorare i livelli chiave e rilevare eventuali breakout. Possiamo usarli per implementare trailing stop sofisticati dove il livello di stop si aggiorna per determinate condizioni.
Sono problemi molto frenquenti. I tutorial di pine-script più elementari descrivono come salvare un valore in una variabile ma descrivono come accedervi di nuovo dopo 10 barre. Un’opzione può essere l’uso dell’indicizzazione per recuperare i valori, ma è utile solo se sappiamo esattamente quando e come accedervi. In questo articolo, esaminiamo la memorizzazione, il recupero e la gestione di valori chiave in qualsiasi momento all’interno dello script.
Come salvare una variabile
Ci sono due modi per salvare una variabile in pine script. Il metodo da scegliere dipende dalla tipologia di condizioni per salvare/scartare la variabile:
- Se il valore della variabile proviene da una condizione fissa (come l’entrata in una posizione), possiamo usare la funzione
valuewhen()integrata in pine script. - Se desideriamo avere un controllo più preciso su quando avviare e interrompere il memorizzazione di una variabile, possiamo usare un operatore condizionale ternario.
Vediamo come applicare entrambi questi metodi tramite una serie di esempi e un esempio finale dove usiamo insieme entrambi i metodi.
Gestire le variabili con Tradingview
I seguenti esempi si basano sull’entrata in una posizione. Quindi usiamo alcuni criteri di ingresso molto semplici. I criteri di ingresso non sono importanti per comprendere il concetto e possono essere tranquillamente ignorati o sostituiti con altri criteri.
Esempio 1 – valuewhen()
In questo primo esempio per mostrare come gestire le variabili con Tradingview, monitoriamo il valore di entrata di un’operazione. Memorizziamo questo valore fino alla chiusura dell’operazione. Questo può essere utile quando abbiamo più posizioni aperte e non possiamo affidarci alla stampa della variabile incorporata strategy.average_price.
Primer valuewhen()
La funzione integrata valuewhen() esamina qualsiasi condizione che gli diamo e restituisce il valore di una riga (che gli specifichiamo) quando la condizione era true l’ultima volta. In realtà se usiamo questa funzione non abbiamo affatto bisogno di salvare una variabile! Invece, richiamiamo solamente il valore corretto.
Di seguito la documentazione ufficiale:
valuewhen
Valore della serie originale quando la condizione era vera all’ennesima occorrenza più recente.valuewhen(condition, source, occurrence) → series
In particolare abbiamo:
- condizione: può essere qualsiasi cosa che restituisca un valore booleano (
trueofalse). Ad esclose > open. - source: Questa è la variabile da cui prendere il valore. Può essere qualsiasi cosa.
open,high,rsi,macdo qualunque cosa gli passiamo. - occorrenza: questo ci consente di accedere non solo al valore più recente ma anche ad altre occorrenze. Se vogliamo il valore più recente, qui inseriamo
0. Se vogliamo il secondo più recente inseriamo1, e così via…
Codice
//@version=3
strategy("Store Value Post - Open", overlay=true)
// SEMPLICE LOGICA DI ENTRATA
sma = sma(close, 200)
strategy.entry("Long", strategy.long, when=close > sma)
// Chiusura dopo 10 barre
bought = strategy.position_size[0] > strategy.position_size[1]
since_entry = barssince(bought)
strategy.close("Long", when=since_entry >=10)
// Ottenre il prezzo di entrata
entry_price = valuewhen(bought, open, 0)
plot(sma, color=orange, title='SMA')
plot(entry_price, title='Entry Price', linewidth=2)
In questo esempio, la condizione all’interno di valuewhen() verifica se la dimensione della posizione è aumentata. In caso affermativo, significa che abbiamo comprato. Dal momento che vogliamo il prezzo di apertura del trade e sappiamo che Tradingview esegue sempre i nostri ordini all’apertura della barra, passiamo la variabile open come source.
Quando eseguiamo la strategia, valuewhen() continua a restituire lo stesso valore fino a quando non effettuiamo un nuovo acquisto. Possiamo vederlo quando posizioniamo il codice sul grafico.
Esempio 2 – Operatore condizionale ternario
Un altro esempo che mostra come gestire le variabili con Tradingview è memorizzare il valore dell’indicatore RSI nel momento in cui apriamo un’operazione LONG e lo conserviamo fino alla chiusura dell’operazione. Se in qualsiasi momento l’RSI scende al di sotto di questo valore chiudiamo la posizione. Per aiutare a visualizzare questo esempio, tracciamo nel grafico il valore RSI memorizzato.
Il codice in questo esempio usa la stessa tecnica descritta nell’articolo sulla gestione della finestra di un segnale. Dato che pine script è un linguaggio di programmazione basato sulle serie, dobbiamo solo assicurarci di continuare a salvare il valore precedente in una linea/serie finché le condizioni non cambiano e vogliamo aggiornarlo.
Nota: se ti stai chiedendo cosa è un linguaggio di programmazione basato sulle serie, significa solamente che costruiamo serie di dati ogni volta che si riceve una nuova candela. Una serie è solo una linea sul grafico e possiamo accedere ai valori precedenti della serie in qualsiasi momento. Per ulteriori informazioni si può leggere l’articolo sull’indicizzazione con pinescript.
Primer per l’operatore condizionale ternario
Abbiamo già descritto in modo dettagliato gli operatori condizionali ternari in un precedente articolo. Anche se il nome fa un po’ paura, in realtà sono piuttosto semplici.
Codice
//@version=3
strategy("Store Value Post - RSI", overlay=false)
// SEMPLICE LOGICA DI ENTRATA
sma = sma(close, 14)
strategy.entry("Long", strategy.long, when=close > sma)
rsi = rsi(close, 14)
// Memorizza il valore RSI di entrata
entry_rsi = na
rsi_close = na
entry_rsi := rsi_close[1] ? na : strategy.position_size[0] > strategy.position_size[1] ? rsi : entry_rsi[1]
// Verifica se dobbiamo chiudere
rsi_close := rsi < entry_rsi
strategy.close("Long", when=rsi_close)
plot(rsi, color=purple, title='RSI')
plot(entry_rsi, style=linebr, title='Entry Value', linewidth=2, color=red)
Questo esempio aumenta il livello la complessità. Il codice usa l’operatore condizionale ternario più o meno allo stesso modo della funzione valuewhen(). Tuttavia, in questo esempio, modifichiamo il livello di entry_rsi anche quando sono soddisfatte le altre condizioni. Per essere più precisi, non aggiorniamo il livello di entry_rsi quando chiudiamo la posizione in modo che il grafico appaia più ordinato.
Nel codice, vediamo che prima dell’operatore condizionale ternario, dobbiamo dichiarare un paio di variabili. Dobbiamo fare riferimento alla variabile entry_rsi nella stessa istruzione dove la calcoliamo e alla variabile rsi_close prima ancora di averla creata! Se non dichiariamo queste veriabile riceviamo un errore.
La variabile rsi_close è la più interessante delle due. Il problema è che vogliamo usare rsi_close per interrompere l’aggiornamento della variabile quando le nostre condizioni di chiusura sono soddisfatte. Tuttavia, allo stesso tempo, possiamo solo calcolare se chiudere la condizione dopo aver calcolato la variabile entry_rsi.
Per affrontare questo problema, controlliamo il valore precedente tramite la condizione rsi_close[1] ? na. Questa è la chiave. Dobbiamo analizzare l’ultima barra e verificare se ci segnala di chiudere la posizione. In pratica, questo si allinea perfettamente con l’indicatore di chiusura sul grafico poiché chiudiamo sempre all’apertura della barra successiva quando inviamo un ordine strategy.close().
Quindi la logica è semplice. Controlliamo se abbiamo aperto una posizione, se lo abbiamo fatto tracciamo il valore RSI all’apertura.
In sintesi, la logica completa dell’operatore condizionale ternario in questo esempio prevede che:
- Abbiamo appena chiuso una posizione?
- SÌ: impostiamo
entry_rsiana– Non è più necessario memorizzare un valore. - NO: allora abbiamo aperto una posizione?
- SI: salviamo il valore
rsiinentry_rsi - NO: salviamo l’ultimo valore
entry_rsiinentry_rsi.
- SI: salviamo il valore
- SÌ: impostiamo
Caricando questo codice in un grafico otteniamo qualcosa di simile a questo:
Esempio 3 – Entrambi
Nell’esempio finale per gestire le variabili con Tradingview, usiamo entrambi i metodi per implementare un sofisticato trailing stop. Creiamo un trailing stop che si muove solo ogni volta che si verifica un nuovo swing di minimo
Il motivo per cui usiamo sia un valuewhen() che un operatore condizionale ternario è per gestire contemporaneamente più condizioni che attivano lo stop.
//@version=3
strategy("Store Value Post - Trailing Stop", overlay=true)
// SEMPLICE LOGICA DI ENTRATA
sma = sma(close, 14)
strategy.entry("Long", strategy.long, when=close > sma)
// Individua gli swing di minimo
// -----------------------
leftbars = 5
rightbars = 2
last_pivot_low = pivotlow(low,leftbars,rightbars)
// Otteniamo il prezzo di stop
stop_price = na
stop_price := strategy.position_size == 0 ? na : valuewhen(last_pivot_low, low[rightbars], 0)
strategy.exit("SL","Long", stop=stop_price)
plot(sma, color=orange, title='SMA')
plot(stop_price, style=linebr, title='Stop Price', linewidth=1, color=red)
//plot(last_pivot_low_value)
Nel codice abbiamo un semplice operatore condizionale ternario. Resettiamo il livello di stop se la dimensione della posizione è zero. (Questo significa che lo stop è stato raggiunto). In caso contrario, usiamo semplicemente il più recente swing di minimo come livello di stop. Infine, usiamo questo livello di stop in strategy.exit() e quando si verifica un nuovo swing, lo stop viene automaticamente aggiornato .
Nei grafici possiamo aspettarci che il prezzo di stop segua gli swing. Notiamo che a causa di un ritardo nel modo in cui sono riconosciuti gli swing, la linea si aggiorna solo dopo il numero di rightbars usato nel codice. In questo caso, sono due barre dopo lo swing.
Nel grafico possiamo vedere come il trailing stop (in rosso) sale ad ogni swing fino a quanto non si chiude la posizione.
Codice completo
In questo articolo abbiamo descritto come gestire le variabili 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
