Inizia

Pinescript

Programmare un colore dinamico all'interno di uno scriptBenvenuto a questo nuovo tutorial che aiuta trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script v5. In questo tutorial programmeremo insieme una variabile input di tipo color all'interno del nostro indicatore. input.color() IMPORTANTE: il codice utilizzato in questo tutorial è stato creato puramente a scopo didattico. Il nostro indicatore è un indicatore semplice che riporta a grafico i dati close dell'asset di riferimento in maniera ponderata. Il dato che verrà visualizzato è la somma di close + il 20%. L'obbiettivo dell'indicatore è di offrire uno strumento completamente dinamico, in grado di variare i parametri dall'interfaccia utente e aggiornarsi automaticamente. Qui di seguito trovi il codice completo per questo tutorial. //@version=5 indicator("Input Tutorial Pt.1 - Color", overlay = false) color_indicator = input.color(defval = color.red, title = "Color") data = close + (close * 0.20) plot(close, color = color_indicator, linewidth = 1) Come si evince dal codice, per creare una variabile dinamica e gestire il colore del nostro indicatore descriviamo una nuova variabile chiamata: color_indicator All'interno della variabile passeremo l'oggetto che ci permette di gestire il colore tramite interfaccia utente popolando l'oggetto: input.color() Il primo valore che passeremo sarà: defval= che si riferisce al valore di default, il valore che il nostro indicatore utilizzerà quando sarà lanciato a grafico. Come valore di default passeremo: color.red Successivamente daremo un titolo alla nostra funzione che ora sarà automaticamente riportata all'interno dell'interfaccia utente con: title='Color' PS: Ricorda che tutti i valori di title dovranno essere ti tipo string e inclusi all'interno delle virgolette (' '). Ecco come apparirà l'interfaccia utente. Ora puoi modificare il colore del tuo indicatore con un solo click e automaticamente l'indicatore aggiornerà il colore. Puoi trovare la guida completa e ufficiale di Trading View su come gestire i colori all'interno di uno script, seguendo il link: www.tradingview.com
CME_MINI:NQ1!Formazione
di thequantscience
Programmare una strategia short e disegnare un indicatore (Pt.3)Benvenuto a questo terzo e ultimo tutorial che vuole aiutare trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script. Nel tutorial di oggi concluderemo la programmazione del nostro semplice algoritmo di tipo strategy, descrivendone attentamente la sintassi. Nel primo tutorial abbiamo analizzato la dichiarazione di una strategia e le sue funzioni base, mentre nel secondo abbiamo implementato il codice per una strategia long only basata sull' indicatore RSI. Il nostro algoritmo acquista long ogni volta che il l'indicatore entra in ipervenduto-oversold (livello 30) vendendo la posizione quando l'indicatore entra in ipercomprato-overbought (livello 70). Oggi completeremo la nostra opera inserendo una terza parte riguardante la strategia di tipo short. Successivamente disegneremo un indicatore molto semplice di tipo visual che terrà traccia dei livelli di prezzo di entrate e uscite per ogni singolo trade. I prezzi delle entrate saranno disegnati con una linea verde, i prezzi delle uscite saranno disegnati con una linea rossa. I parametri della strategia di oggi sono i seguenti, apertura short ogni volta che l' indicatore entra in ipercomprato-overbought (livello 70), chiusura della posizione quando l' indicatore entra in ipervenduto-oversold (livello 35). Una cosa molto importante prima di iniziare: non utilizzare questo script per prendere decisioni di investimento. Utilizza questo codice esclusivamente per esercitarti, testare e comprendere il linguaggio Pine Script. Qui sotto trovi il codice sorgente, puoi copiarlo e incollarlo all' interno della tua console di Trading View. Salva il codice e aggiungilo allo schermo. //@version=5 strategy(title = " Strategy Tutorial - The Quant Science™ ", overlay = false, initial_capital = 1000, currency = currency.EUR, commission_type = strategy.commission.percent, commission_value = 0.03, slippage = 10, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, process_orders_on_close = true) //------------------------------------------------------------ Pt. 2 rsi = ta.rsi(close, 14) buyLong = ta.crossunder(rsi ,30) closingLong = ta.crossover(rsi ,70) priceEntry = ta.valuewhen(buyLong, close, 0) priceExit = ta.valuewhen(closingLong, close, 0) if buyLong and strategy.opentrades == 0 strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry) strategy.entry(id = "Open Long Trade", direction = strategy.long) if closingLong strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit) //------------------------------------------------------------ Pt. 3 sellShort = ta.crossover(rsi, 70) closingShort = ta.crossunder(rsi, 35) priceShortEntry = ta.valuewhen(sellShort, close, 0) priceShortExit = ta.valuewhen(closingShort, close, 0) if sellShort and strategy.opentrades == 0 strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry) strategy.entry(id = "Open Short Trade", direction = strategy.short) if closingShort strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit) plot(priceShortEntry, style = plot.style_line, color = color.green) plot(priceShortExit, style = plot.style_line, color = color.red) Come puoi notare abbiamo separato ogni parte del codice sviluppata in ciascun tutorial. Iniziamo quindi ad analizzare il nostro nuovo codice sorgente descrivendone la sintassi stringa dopo stringa. sellShort = ta.crossover(rsi, 70) Dichiariamo una variabile chiamata "sellShort". Servirà per definire quando il nostro algoritmo dovrà aprire la posizione short. Tramite ta.crossover() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di ingresso. Come pattuito in precedenza acquistiamo sul livello di overbought pari a 70. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 70 (il livello di ipercomprato). closingShort = ta.crossunder(rsi, 35) Ora andiamo a dichiarare la variabile che chiameremo "closingShort". Servirà per definire quando il nostro algoritmo dovrà chiudere la posizione short. Tramite ta.crossunder() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di uscita. Come pattuito in precedenza chiudiamo la posizione short sul livello di oversold pari a 35. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 35 (il livello di ipervenduto). priceShortEntry = ta.valuewhen(sellShort, close, 0) Isoliamo il prezzo di ingresso dichiarando una variabile "priceShortEntry". Servirà per definire il prezzo esatto dell' ingresso short. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione, il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione sellShort, come source close e come occurrence 0. priceShortExit = ta.valuewhen(closingShort, close, 0) Isoliamo il prezzo di uscita dichiarando una variabile "priceShortExit". Servirà per definire il prezzo esatto dell' uscita short. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione, il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione closingShort, come source close e come occurrence 0. if sellShort and strategy.opentrades == 0 Ora che abbiamo definito le condizioni del nostro algoritmo andiamo a implementare la parte che farà interagire le nostre condizioni creando una vera e propria strategia. Questa stringa è divisa in quattro differenti parti: 1. if: la condizione 'if' definisce quali azioni vanno eseguite se le condizioni sono soddisfatte 2. sellShort: la nostra condizione di ingresso 3. and: letteralmente 'e' offre la possibilità di combinare una seconda condizione 4. strategy.opentrades == 0: indica i numeri di ordini a mercato aperti che in questo caso dovranno essere uguali a 0. In definitiva se la condizione di ingresso è soddisfatta e nessun altro ordine è a mercato, allora si eseguirà l' inserimento dell' ordine short, che analizzeremo di seguito. strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry) Attraverso la funzione strategy.order() definiremo l'invio dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Short Trade"), direction = strategy.short (la direzione dell'ordine, che in questo caso è di tipo short) e limit = priceShortEntry (prezzo a cui dovrà essere eseguito l'ordine, in questo caso uguale a "priceShortEntry"). strategy.entry(id = "Open Short Trade", direction = strategy.short) Attraverso la funzione strategy.entry() dichiareremo l'esecuzione dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Short Trade") e direction = strategy.short (la direzione dell'ordine, che in questo caso è di tipo short). Ora tutte le volte che le condizioni sono soddisfatte e il capitale è libero il nostro algoritmo acquisterà short al prezzo definito dalla nostra condizione. Continuiamo comunicando al nostro script quando vogliamo chiudere la posizione. if closingShort Implementiamo la condizione che dovrà essere soddisfatta per l'uscita del trade, ovvero quando l' indicatore rsi si trova a livello 35, il livello di oversold o ipervenduto (per la strategia short). strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit) Attraverso la funzione strategy.exit() definiremo la chiusura del trade short. All' interno di questa funzione passiamo un id (nome dell'ordine "Close Short Trade"), from_entry = "Open Short Trade" (indichiamo l'id dell' ordine che deve essere chiuso) e il prezzo di esecuzione stop = priceShortExit (prezzo a cui dovrà essere eseguita la chiusura, in questo caso uguale a "priceShortExit"). Molto bene, ora abbiamo concluso la programmazione operativa del nostro script è il momento di aggiungere un indicatore che ci permetterà di visualizzare i prezzi di entrata e uscita. In Pine Script, come abbiamo visto nello scorso tutorial, la funzione che si utilizza per disegnare dei valori si chiama plot. plot(priceShortEntry, style = plot.style_line, color = color.green) Definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della serie da disegnare ovvero il prezzo di entrata, priceShortEntry. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore verde con color = color.green. plot(priceShortExit, style = plot.style_line, color = color.red) Definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della seconda serie da disegnare ovvero il prezzo di uscita, priceShortExit. Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore rosso con color = color.red. Puoi trovare tutti gli stili disponibili e i colori con cui puoi configurare il tuo indicatore all' interno del manuale Pine Script. NB: è probabile che copiando il codice nella tua console ti ritroverai una dicitura errata al posto di 'rsi'. Questo è un errore (probabilmente momentaneo e dovuto all'aggiornamento) di Trading View. Per risolvere questo problema, dovrai sostituire la dicitura errata con quella corretta. Qui sotto trovi la versione del codice in versione testo che ti aiuterà a risolvere questo problema. Sostituisci quindi le diciture errate con quelle corrette che trovi nel codice in versione testo, qui sotto. //@version=5 strategy(title = " Strategy Tutorial - The Quant Science™ ", overlay = false, initial_capital = 1000, currency = currency.EUR, commission_type = strategy.commission.percent, commission_value = 0.03, slippage = 10, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, process_orders_on_close = true) //------------------------------------------------------------ Pt. 2 rsi = ta.rsi(close, 14) buyLong = ta.crossunder(rsi ,30) closingLong = ta.crossover(rsi ,70) priceEntry = ta.valuewhen(buyLong, close, 0) priceExit = ta.valuewhen(closingLong, close, 0) if buyLong and strategy.opentrades == 0 strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry) strategy.entry(id = "Open Long Trade", direction = strategy.long) if closingLong strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit) //------------------------------------------------------------ Pt. 3 sellShort = ta.crossover(rsi, 70) closingShort = ta.crossunder(rsi, 35) priceShortEntry = ta.valuewhen(sellShort, close, 0) priceShortExit = ta.valuewhen(closingShort, close, 0) if sellShort and strategy.opentrades == 0 strategy.order(id = "Open Short Trade", direction = strategy.short, limit = priceShortEntry) strategy.entry(id = "Open Short Trade", direction = strategy.short) if closingShort strategy.exit(id = "Close Short Trade", from_entry = "Open Short Trade", stop = priceShortExit) plot(priceShortEntry, style = plot.style_line, color = color.green) plot(priceShortExit, style = plot.style_line, color = color.red) Ci vediamo presto con nuovi tutorial !
Selezione editoriale
Formazione
di thequantscience
Programmare una strategia long e disegnare un indicatore (Pt. 2)Benvenuto a questo secondo tutorial che vuole aiutare trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script. Nel tutorial di oggi continueremo a programmare il nostro semplice algoritmo di tipo strategy , descrivendone attentamente la sintassi. Nel primo tutorial abbiamo analizzato la dichiarazione di una strategia e le sue funzioni base, oggi implementeremo il codice per una strategia long only basata sull' indicatore RSI. Il nostro algoritmo acquisterà long ogni volta che il l'indicatore entra in ipervenduto-oversold (livello 30) vendendo la posizione quando l'indicatore entra in ipercomprato-overbought (livello 70). Successivamente disegneremo un indicatore molto semplice di tipo visual che terrà traccia dei livelli di prezzo di entrate e uscite per ogni singolo trade. I prezzi delle entrate saranno disegnati con una linea verde, i prezzi delle uscite saranno disegnati con una linea rossa. Una cosa molto importante prima di iniziare: non utilizzare questo script per prendere decisioni di investimento. Utilizza questo codice esclusivamente per esercitarti, testare e comprendere il linguaggio Pine Script. Qui sotto trovi il codice sorgente, puoi copiarlo e incollarlo all' interno della tua console di Trading View. Salva il codice e aggiungilo allo schermo. //@version=5 strategy(title = " Strategy Tutorial - The Quant Science™ ", overlay = false, initial_capital = 1000, currency = currency.EUR, commission_type = strategy.commission.percent, commission_value = 0.03, slippage = 10, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, process_orders_on_close = true) //------------------------------------------------------------ Pt. 2 rsi = ta.rsi(close, 14) buyLong = ta.crossunder(rsi, 30) closingLong = ta.crossover(rsi, 70) priceEntry = ta.valuewhen(buyLong, close, 0) priceExit = ta.valuewhen(closingLong, close, 0) if buyLong and strategy.opentrades == 0 strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry) strategy.entry(id = "Open Long Trade", direction = strategy.long) if closingLong strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit) plot(priceEntry, style = plot.style_line, color = color.green) plot(priceExit, style = plot.style_line, color = color.red) Come puoi notare abbiamo separato la prima parte del codice svolta nel primo tutorial con la seconda parte. Iniziamo quindi ad analizzare il nostro codice sorgente descrivendone la sintassi stringa dopo stringa. rsi = ta.rsi(close, 14) : creiamo una variabile a cui assegnamo la funzione built-in ta.rsi() , questa funzione ci permette di accedere velocemente all' indicatore RSI. All' interno della funzione passiamo il source e il periodo . Impostiamo quindi close e il periodo di 14 , in questo modo l' indicatore sarà calcolato sulla chiusura di ogni barra prendendo le ultime 14 barre passate. buyLong = ta.crossunder(rsi, 30) : successivamente andiamo a dichiarare una seconda variabile che chiameremo "buyLong". Servirà per definire quando il nostro algoritmo dovrà aprire la posizione long. Tramite ta.crossunder() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di ingresso. Come pattuito in precedenza acquistiamo sul livello di oversold pari a 30. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 30 (il livello di ipervenduto). closingLong = ta.crossover(rsi, 70) : ora andiamo a dichiarare la variabile che chiameremo "closingLong". Servirà per definire quando il nostro algoritmo dovrà chiudere la posizione long. Tramite ta.crossover() accediamo alla funzione built-in che ci permette di passare due elementi e definire la condizione di uscita. Come pattuito in precedenza vendiamo la posizione long sul livello di overbought pari a 70. Passeremo all' interno di questa funzione quindi rsi (la variabile che ingloba il nostro indicatore) e 70 (il livello di ipercomprato). priceEntry = ta.valuewhen(buyLong, close, 0) : isoliamo il prezzo di ingresso dichiarando una variabile "priceEntry". Servirà per definire il prezzo esatto dell' ingresso long. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione , il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione buyLong , come source close e come occurrence 0 . priceExit = ta.valuewhen(closingLong, close, 0) : isoliamo il prezzo di uscita dichiarando una variabile "priceExit". Servirà per definire il prezzo esatto dell' uscita long. Tramite ta.valuewhen() accediamo alla funzione built-in che ci permette di passare tre elementi, il primo elemento è la condizione , il secondo è un elemento di tipo source e il terzo elemento è un elemento di tipo int chiamato occurrence. Passiamo all' interno di questa funzione la condizione closingLong , come source close e come occurrence 0 . if buyLong and strategy.opentrades == 0 : ora che abbiamo definito le condizioni del nostro algoritmo andiamo a implementare la parte che farà interagire le nostre condizioni creando una vera e propria strategia. Questa stringa è divisa in quattro differenti parti: 1. if : la condizione 'if' definisce quali azioni vanno eseguite se le condizioni sono soddisfatte 2. buyLong : la nostra condizione di ingresso 3. and : letteralmente 'e' offre la possibilità di combinare una seconda condizione 4. strategy.opentrades == 0 : indica i numeri di ordini a mercato aperti che in questo caso dovranno essere uguali a 0. In definitiva se la condizione di ingresso è soddisfatta e nessun altro ordine è a mercato, allora si eseguirà l' inserimento dell' ordine long, che analizzeremo di seguito. strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry) : attraverso la funzione strategy.order() definiremo l'invio dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade"), direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long) e limit = priceEntry (prezzo a cui dovrà essere eseguito l'ordine, in questo caso uguale a "priceEntry"). strategy.entry(id = "Open Long Trade", direction = strategy.long) : attraverso la funzione strategy.entry() dichiareremo l'esecuzione dell' ordine a mercato. All' interno di questa funzione passiamo un id (nome dell'ordine "Open Long Trade") e direction = strategy.long (la direzione dell'ordine, che in questo caso è di tipo long). Ora tutte le volte che le condizioni sono soddisfatte e il capitale è libero il nostro algoritmo acquisterà long al prezzo definito dalla nostra condizione. Continuiamo comunicando al nostro script quando vogliamo chiudere la posizione. if closingLong : implementiamo la condizione che dovrà essere soddisfatta per l'uscita del trade, ovvero quando l' indicatore rsi si trova a livello 70, il livello di overbought o ipercomprato. strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit) : attraverso la funzione strategy.exit() definiremo la chiusura del trade long. All' interno di questa funzione passiamo un id (nome dell'ordine "Close Long Trade"), from_entry = "Open Long Trade" (indichiamo l'id dell' ordine che deve essere chiuso) e il prezzo di esecuzione stop = priceExit (prezzo a cui dovrà essere eseguita la chiusura, in questo caso uguale a "priceExit"). Molto bene, ora abbiamo concluso la programmazione operativa del nostro script è il momento di aggiungere un indicatore che ci permetterà di visualizzare i prezzi di entrata e uscita. In Pine Script la funzione che si utilizza per disegnare dei valori si chiama plot . plot(priceEntry, style = plot.style_line, color = color.green) : definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della serie da disegnare ovvero il prezzo di entrata, priceEntry . Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore verde con color = color.green . plot(priceExit, style = plot.style_line, color = color.red) : definiamo dei valori da disegnare tramite plot(), all'interno di questa funzione passeremo il valore della seconda serie da disegnare ovvero il prezzo di uscita, priceExit . Successivamente definiamo lo stile dell' indicatore con style = plot.style_line e il colore rosso con color = color.red . Puoi trovare tutti gli stili disponibili e i colori con cui puoi configurare il tuo indicatore all' interno del manuale Pine Script. Ci vediamo al prossimo tutorial dove analizzeremo il codice della strategia per la versione short. Se riscontri problemi durante il salvataggio dello script, copia e incolla il codice qui sotto, se continui a riscontrare problemi non esitare a contattarci. //@version=5 strategy(title = " Strategy Tutorial - The Quant Science™ ", overlay = false, initial_capital = 1000, currency = currency.EUR, commission_type = strategy.commission.percent, commission_value = 0.03, slippage = 10, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, process_orders_on_close = true) //------------------------------------------------------------ Pt. 2 rsi = ta.rsi(close, 14) buyLong = ta.crossunder(rsi, 30) closingLong = ta.crossover(rsi, 70) priceEntry = ta.valuewhen(buyLong, close, 0) priceExit = ta.valuewhen(closingLong, close, 0) if buyLong and strategy.opentrades == 0 strategy.order(id = "Open Long Trade", direction = strategy.long, limit = priceEntry) strategy.entry(id = "Open Long Trade", direction = strategy.long) if closingLong strategy.exit(id = "Close Long Trade", from_entry = "Open Long Trade", stop = priceExit) plot(priceEntry, style = plot.style_line, color = color.green) plot(priceExit, style = plot.style_line, color = color.red)
Selezione editoriale
Formazione
di thequantscience
8
Come impostare uno script strategy con Pine Script Benvenuto a questo primo tutorial che vuole aiutare trader e investitori a comprendere al meglio il potente linguaggio di programmazione Pine Script. Pine Script permette di utilizzare due forme differenti di script; strategy e indicator. Ciascuna ha le proprie caratteristiche tecniche che devono essere comprese prima di iniziare a sviluppare il proprio progetto. Che cos'è uno script ? In generale nel mondo della programmazione uno script è un insieme di stringhe di codice che permette di compiere determinate funzioni nella vita reale, possiamo quindi considerare uno script come un piccolo software che compie determinate azioni. In questo caso gli script programmabili su Trading View permettono di compiere funzioni e azioni inerenti al mondo del trading e della finanza. In Pine Script esistono due tipologie di script: 1) Strategy: con funzioni e variabili dedicate permettono di generare un backtesting per una determinata strategia. 2) Indicator: permettono di creare visual tool e vengono spesso utilizzati per creare mini applicazioni, tabelle e indicatori personalizzabili. Nel tutorial di oggi analizzeremo gli script strategy . Qui di seguito trovi un esempio di codice introduttivo, il codice si riferisce solo alla parte iniziale di uno script di tipo strategy e ti aiuterà a comprendere al meglio come impostare e configurare la parte iniziale del tuo script. //@version=5 strategy(title = " Strategy Tutorial - The Quant Science ™ ", overlay = false, initial_capital = 1000, currency = currency.EUR, commission_type = strategy.commission.percent, commission_value = 0.03, slippage = 10, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, process_orders_on_close = true) Come avrai notato, la parte iniziale di uno script inizia sempre con la dichiarazione della versione di Pine Script che stiamo utilizzando. Nel nostro esempio utilizziamo l'ultima versione rilasciata da Trading View, la versione 5. Quindi dichiareremo la versione con: //@version=5 In seguito alla dichiarazione della versione utilizzata, andremo a dichiarare la tipologia di script che vogliamo utilizzare, in questo caso inseriremo: strategy() . All' interno delle parentesi doppie possiamo definire e aggiungere caratteristiche di base al nostro script. In questo esempio non abbiamo riportato tutte le variabili disponibili da includere all' interno di una strategia ma solo alcune. Per visualizzare tutte le variabili puoi consultare la guida Pine Script V5 oppure semplicemente fare doppio click su "strategy" dalla tua console di Trading View. Iniziamo ad arricchire le funzionalità base del nostro script strategy: title : si riferisce al nome che vogliamo assegnare al nostro script e tramite il quale gli utenti potranno ricercarlo all' interno della libreria di Trading View. overlay : permette di proiettare il nostro indicatore, impostato su true l' indicatore sarà applicato sul grafico, impostato su false l' indicatore sarà proiettato sotto al grafico. initial_capital : si riferisce all'ammontare di capitale iniziale che utilizzerai per la tua strategia. In questo esempio impostiamo 1000. currency : si riferisce alla valuta base con cui desideri calcolare le performance della tua strategia, in questo caso scegliamo come moneta EUR (Euro). Trading View offre la possibilità di scegliere una vasta gamma di valute base, puoi trovare maggiori informazioni al riguardo all' interno della guida. Per impostare la valuta Euro quindi inseriremo: currency.EUR. commission_type : si riferisce al modo in cui vogliamo calcolare le commissioni, Possiamo scegliere tre differenti tipologie di calcolo: strategy.commission.percent , strategy.commission.cash_per_contract , strategy.commission.cash_per_order . Di default lo script strategy calcola le commissioni in maniera percentuale, se non viene dichiarato un altro metodo. commission_value : si riferisce al valore della commissione che il tuo broker applica a ciascun trade, in questo esempio utilizziamo Kucoin Exchange che applica una commissione dello 0.03% per l' apertura e 0.03% per la chiusura di ogni singolo trade. slippage : è espresso in tick, questo valore viene aggiunto o sottratto al prezzo degli ordini market/stop per rendere il prezzo meno favorevole per la strategia, creando così un backtesting più reale. Nel nostro esempio impostiamo a 10 tick il nostro slippage. default_qty_value : si riferisce alla quantità da investire ad ogni singolo trade, in questo caso investiamo il 100% del capitale per ogni singolo trade. default_qty_type : si riferisce al tipo di calcolo con cui misurare il capitale investito per ogni singolo trade, nel nostro esempio dichiariamo strategy.percent_of_equity che si riferisce al calcolo percentuale (avendo inserito 100 precedentemente). process_orders_on_close : se impostato su true , genera un ulteriore tentativo di esecuzione degli ordini dopo la chiusura di una barra. Se gli ordini sono a mercato, lo script li esegue prima dell'apertura della barra successiva. Se gli ordini dipendono dal prezzo, saranno eseguiti solo se le condizioni di prezzo sono soddisfatte. Questa opzione è utile se si desidera chiudere le posizioni nella barra corrente. L'opzione predefinita è false . Per il nostro esempio scegliamo true . Abbiamo concluso il nostro breve tutorial sulla dichiarazione di uno script di tipo strategy . In questo esempio abbiamo mostrato in maniera molto veloce alcune delle funzioni base con cui impostare il tuo algoritmo. Puoi trovare maggiori informazioni e tutte le funzioni disponibili consultando il manuale per il linguaggio Pine Script.
Selezione editoriale
Formazione
di thequantscience
6
NZDCHF : Approfittiamo della correzione.L'ultima volta che ho pubblicato un post su questa coppia di valute è stato il 12 ottobre 2019 in cui avevo una visione rialzista. Adesso analizzando il grafico daily trovo 5 serie di swing positive dopo il minimo di settembre 2019. Nelle ultime giornate ha mostrato il primo segno di debolezza rompendo i minimo degli ultimi swing positivi. Da questo possiamo intuire che il trend possa aver raggiunto un massimo momentaneo creando un area di resistenza con doppio massimo. A questo punto possiamo approfittare della correzione per un ingresso short. A rafforzare la mia idea trovo lo script dei breakout di volatilità che mi segnala un ingresso short dopo che il prezzo ha raggiunto il valore segnato dalla linea rossa tratteggiata. In aggiunta un secondo script mi dice che il Pin>70 proprio in area massimo quindi l'ingresso short era molto evidente. L'ingresso short è comunque ancora valido quindi approfittiamo della ema200 per entrare short. Resta inoltre il fatto che il trend di fondo è ribassista. Con stop sopra i massimi e takeprofit in area 0.6330 abbiamo un R/R di 1:1,6. Se siete d'accordo con la mia idea lasciate un like. Buona giornata e buon trading a tutti.
Short
di LuTrader_LB
AZIMUT : Trade di breve.Dopo l'ultimo picco massimo effettuato al di sopra delle bande di bollinger 200 abbiamo visto come il prezzo sia crollato formando un canale ribassista su cui si muove attualmente il quale minimo è arrivato a 21.20 dopo essere rientrato all'interno delle bande. Adesso possiamo notare come il prezzo abbia lateralizzato arrivando ad appoggiarsi di nuovo alla banda superiore che usa come resistenza. Si può anche notare che la media a 15 periodi sia anch'essa rientrata all'interno delle bande mantenendosi sopra i prezzi fungendo così da resistenza dinamica. Solo da questi indizi possiamo capire che ci troviamo ancora in un area di massimo ma a confermare ancor di più il mio pensiero mi trovo i parametri dei miei script che mi indicano che il pin2 è maggiore di 70 e che già la conferma per lo short è avvenuta quindi possiamo già entrare short con uno stop di sicurezza in area 21.95 e un take profit in area 20.10 avendo così un trade dal R/R di 1:2,3.
MIL:AZMShort
di LuTrader_LB