Salve a tutti, ieri ho trovato un nuovo indicatore su tradingview basato sul momentum e sulle bande di bollinger che mi sembra molto interessante, e mi piacerebbe sapere se lo si può tradurre in linguaggio prorealtime per poterlo testare su alcuni grafici…. ecco il link:

https://it.tradingview.com/script/cuOxHXe3-Mean-Deviation-Loop-Lyro-RS/

Ed ecco il codice pine-script:

//

Importazione libreria TradingView/ta/9 come ta    

import LyroRS/LMAs/1 come DynamicMA   

// Gruppi di input

indi_settings_g = “Gruppi di input”   

bb_g = “Gruppi di input”   

fl_g = “Gruppi di input”   

combined_sig_g = “Gruppi di input 𝗦𝗜𝗚𝗡𝗔𝗟”   

table_g = “𝗧𝗔𝗕𝗟𝗘”   

colors_g = “𝗖𝗢𝗟𝗢𝗥𝗦”  

// Ingressi

// — Impostazioni indicatore

source = input.source ( close , “Source” , tooltip = “Seleziona la sorgente del prezzo (ad esempio, chiusura, apertura, massimo,  minimo) utilizzata per i calcoli.” , group = indi_settings_g )      

signal_mode = input.string ( “Bande di Bollinger” , “Modalità segnale” ,     tooltip = “Seleziona la logica utilizzata per generare i segnali: BB, Loop o Segnale combinato.” , group = indi_settings_g , options = [ “Bande di Bollinger” , “Ciclo For” , “Segnale combinato” ])

// — BB

ma_benchmark_type_bb = input.string ( “EMA” , “Seleziona media mobile BB” , options = [ “SMA” , “EMA” , “WMA” , “VWMA” , “DEMA” , “TEMA” , “RMA” , “HMA” , “LSMA” , “SMMA” , “ALMA” , “ZLSMA” , “FRAMA” , “KAMA” , “JMA” , “T3” ] , group = bb_g , tooltip = “Scegli un tipo di media mobile da applicare nei calcoli .” )                      

mad_length_bb = input.int ( 25 , “Lunghezza media mobile BB” , tooltip = “Il periodo di lookback per il calcolo della deviazione media assoluta (MAD) attorno alla media mobile selezionata (per il calcolo in stile Bollinger Band).” , group = bb_g )      

mad_multp = input.float ( 1.4 , “+ Moltiplicatore” , tooltip = “Un moltiplicatore applicato alla distanza MAD dalla  media per creare la banda MAD superiore.” , group = bb_g )      

mad_multn = input.float ( 1 , “- Moltiplicatore” , tooltip = “Un moltiplicatore applicato alla distanza MAD dalla  media per creare la banda MAD inferiore.” , group = bb_g )     

// — Ciclo For

ma_benchmark_type_fl = input.string ( “ALMA” , “Seleziona media mobile BB” , options = [ “SMA” , “EMA” , “WMA” , “VWMA” , “DEMA” , “TEMA” , “RMA” , “HMA” , “LSMA” , “SMMA” , “ALMA” , “ZLSMA” , “FRAMA” , “KAMA” , “JMA” , “T3” ] , group = fl_g , tooltip = “Seleziona un tipo di media mobile utilizzato nei calcoli del ciclo For.” )                      

mad_length_fl = input.int ( 10 , “Lunghezza del ciclo For” , tooltip = “Il periodo di lookback per il calcolo della deviazione assoluta media (MAD) attorno alla media mobile selezionata (calcolo in stile ciclo For).” , group = fl_g )     

a_ = input.int ( 10 , “Da” , tooltip = “Imposta l’indice iniziale per l’iterazione del ciclo.” , group = fl_g )      

b_ = input.int ( 60 , “A” , tooltip = “Imposta l’indice finale per l’iterazione del ciclo.” , group = fl_g )     

Threshold_L_Fl = input.int ( 23 , “Soglia lunga” , step = 1 , tooltip = “Definisce il livello di soglia al di sopra del quale viene rilevato un trend rialzista.” , group = fl_g )       

Threshold_S_Fl = input.int ( 3 , “Soglia corta” , step = 1 , tooltip = “Definisce il livello di soglia al di sotto del quale viene rilevato un trend ribassista.” , group = fl_g )      

// — Soglia del segnale combinato_L_C

= input.float ( 0 , ” Soglia lunga” , step = 0.01 ,      tooltip = “Il segnale combinato deve essere ≥ questo per attivare un  segnale lungo.” , group = combined_sig_g , maxval = 1 , minval = 0 )

Threshold_S_C = input.float ( 0 , “Soglia breve” , step = 0.01 ,      tooltip = “Il segnale combinato deve essere < questo per attivare un  segnale breve.” , group = combined_sig_g , maxval = 0 , minval = -1 )

// — Tabelle

fo = input.bool ( false , ‘Forza sovrapposizione tabella’ , display = display.none , group = table_g , tooltip = ‘Consente di forzare la sovrapposizione della tabella sul grafico .’ )            

enable_table = input.bool ( true , ” , display = display.none , group = table_g , inline = “T” )           

pos_table = input.string ( ‘Centro destra’ , ‘Tabella modalità trend MAD ‘ , options = [ ‘In alto a sinistra’ , ‘Centro sinistra’ , ‘In basso a sinistra’ , ‘ In alto a destra’ , ‘Centro destra’ , ‘ In basso a destra’ , ‘Al centro in alto’ , “Centro centrale” , ‘Centro inferiore’ ] , group = table_g , display = display.none , inline = “T” )                       

table_size_input = input.string ( “Normale” , ” , options = [ “Enorme” , “Grande” , “Normale” , “Piccolo” , “Minuscolo” ] , group = table_g , tooltip = “Impostazioni per la tabella Modalità di tendenza MAD.” , display = display.none , inline = “T” )                  

// Input colore

ColMode = input.string ( “Mystic” , “Custom Color Palette” , inline = “drop” , options = [ “Classic” , “Mystic” , “Accented” , “Royal” ] , display = display.none , group = colors_g , tooltip = “Scegli uno schema di colori predefinito per la visualizzazione degli indicatori.” )            

cpyn = input.bool ( true , “Usa tavolozza personalizzata” , tooltip = “Abilita la selezione manuale di colori personalizzati per i segnali di tendenza.” , group = colors_g , display = display.none )        

cp_UpC = input.color ( #00ff00 , “Personalizza su” , inline = “Tavolozza personalizzata” , tooltip = “Imposta un colore personalizzato per i segnali rialzisti.” , group = colors_g , display = display.none )          

cp_DnC = input.color ( #ff0000 , “Personalizza giù” , inline = “Tavolozza personalizzata” , tooltip = “Imposta un colore personalizzato per i segnali ribassisti.” , group = colors_g , display = display.none )         

// Colori

colore UpC = na    

colore DnC = na   

cambia ColMode  “Classico” => UpC := #00E676 DnC := #880E4F “Mistico” => UpC := #30FDCF DnC := #E117B7 “Accentato” => UpC := #9618F7 DnC := #FF0078 “Reale” => UpC := #FFC107 DnC := #673AB7

se cpyn  UpC := cp_UpC DnC := cp_DnC

// Tavolo

// — Definizione della dimensione della tabella

var string table_size = na    

// — Cambio dimensione tabella

switch table_size_input  “Enorme” => table_size := size.huge “Grande” => table_size := size.large “Normale” => table_size := size.normal “Piccolo” => table_size := size.small “Minuscolo” => table_size := size.tiny

// — Posizione di commutazione

pot ( posizione ) =>  var pos = posizione interruttore ‘In alto a sinistra’ = > position.top_left ‘In centro a sinistra’ => position.middle_left ‘In basso a sinistra’ = > position.bottom_left ‘In alto a destra’ = > position.top_right ‘In centro a destra’ => position.middle_right ‘In basso a destra’ = > position.bottom_right ‘In alto al centro’ => position.top_center “In centro al centro” => position.middle_center ‘In basso al centro’ => position.bottom_center pos

// Funzione di deviazione assoluta media

mad ( src , benchmark , length ) =>    sum_abs_diff = 0.0 per i = 0 a length – 1 diff = math.abs ( src [ i ] -benchmark ) sum_abs_diff := sum_abs_diff + diff sum_abs_diff / length

// Sistema    For Loop ( src , a , b ) => totale = 0,0 per i = da a a b di 1 totale += ( src > src [ i ] ? 1 : -1 ) totale totale

// Cambio media mobile

ma_switch ( src , lunghezza , tipo_media ) =>    media = switch tipo_media “SMA” => DynamicMA . SMA ( src , lunghezza ) “EMA” => DynamicMA . EMA ( src , lunghezza ) “WMA” => DynamicMA . WMA ( src , lunghezza ) “VWMA” => DynamicMA . VWMA ( src , volume , lunghezza ) “DEMA” => DynamicMA . DEMA ( src , lunghezza ) “TEMA” => DynamicMA . TEMA ( src , lunghezza ) “RMA” => DynamicMA . RMA ( src , lunghezza ) “HMA” => DynamicMA . HMA ( src , lunghezza ) “LSMA” => DynamicMA . LSMA ( src , lunghezza , 0 ) “SMMA” => DynamicMA . SMMA ( src , lunghezza ) “ALMA” => DynamicMA . ALMA ( src , lunghezza , 0 , 20 ) “ZLSMA” => DynamicMA . ZLSMA ( src , lunghezza ) “FRAMA” => DynamicMA . FRAMA ( src , lunghezza ) “KAMA” => DynamicMA . KAMA ( src , lunghezza ) “JMA” => DynamicMA . JMA ( src , lunghezza , 0.5 ) “T3” = > DynamicMA .T3 ( src ,

             lunghezza , 0,5 ) 

// Elaborazione finale

// — Definizione delle variabili

avg_bb = ma_switch ( source , mad_length_bb , ma_benchmark_type_bb )     

avg_fl = ma_switch ( source , mad_length_fl , ma_benchmark_type_fl )    

mad_value = mad ( sorgente , avg_bb , mad_length_bb )     

mad2 = mad ( sorgente , avg_fl , mad_length_fl )    

// — BB 

bb_positive_band = avg_bb + ( mad_value * mad_multp )       

bb_negative_band = avg_bb – ( mad_value * mad_multn )      

// Ciclo For

mad_w_src = ma_switch ( source * mad2 , mad_length_fl , ma_benchmark_type_fl ) / ma_switch ( mad2 , mad_length_fl , ma_benchmark_type_fl ) // MAD combinato con la sorgente dell’indicatore           

mad_fl = system ( mad_w_src , a_ , b_ )    

// Variabile punteggio

var int score = 0     

var int bb_score = 0     

var int fl_score = 0     

var int combined_signal = 0    

// Condizioni

// — BB

se ta.crossover ( sorgente , bb_positive_band )   bb_score := 1

se ta.crossunder ( sorgente , bb_negative_band )   bb_score := -1

se signal_mode == “Bande di Bollinger”    se ta.crossover ( sorgente , bb_positive_band ) punteggio := 1

    se ta.crossunder ( sorgente , bb_negative_band )   punteggio := -1

// — FL

se ta.crossover ( mad_fl , Threshold_L_Fl )   fl_score := 1

se ta.crossunder ( mad_fl , Threshold_S_Fl )   fl_score := -1

se signal_mode == “Ciclo For”    se ta.crossover ( mad_fl , Threshold_L_Fl ) punteggio := 1

    se ta.crossunder ( mad_fl , Threshold_S_Fl )   punteggio := -1

// — Segnale combinato

c_signal = math.avg ( bb_score , fl_score )   

se ta.crossover ( c_signal , Threshold_L_C )   combined_signal := 1

se ta.crossunder ( c_signal , Threshold_S_C )   combined_signal := -1

se signal_mode == “Segnale combinato”    se ta.crossover ( c_signal , Threshold_L_C ) punteggio := 1

    se ta.crossunder ( c_signal , Threshold_S_C )   punteggio := -1

// Colore del grafico

pc = punteggio == 1 ? UpC : punteggio == -1 ? DnC : colore.grigio               

pc_bb = punteggio_bb == 1 ? UpC : punteggio_bb == -1 ? DnC : colore.grigio               

pc_fl = punteggio_fl == 1 ? UpC : punteggio_fl == -1 ? DnC : colore.grigio               

pc_combined = segnale_combinato == 1 ? UpC : segnale_combinato == -1 ? DnC : colore.grigio              

// Tabelle

var table mode_stat_table = na    

// — Forza le condizioni di sovrapposizione

se fo // ‘fo’ è un input, ma utilizzato in un blocco if, non  direttamente in table.new   mode_stat_table := table.new ( pot ( pos_table ) , 100 , 100 , frame_width = 1 , frame_color = color.gray , force_overlay = true , border_color = color.gray , border_width = 1 )

altrimenti mode_stat_table := table.new ( pot ( pos_table ) , 100 , 100 , frame_width = 1 , frame_color = color.gray , force_overlay = false , border_color = color.gray , border_width = 1 )

// — Celle della tabella

if enable_table  table.cell ( mode_stat_table , 0 , 0 , ‘Tabella delle modalità di tendenza MAD | 𝓛𝓎𝓇𝓸 𝓡𝓢’ , text_color = color.white , bgcolor = #000000 , text_size = table_size ) table.cell ( mode_stat_table , 1 , 0 , ” , text_color = color.white , bgcolor = #000000 , text_size = table_size )

    table.cell ( mode_stat_table , 0 , 1 , ‘Modalità:’ , text_color = color.white , bgcolor = #000000 , text_size = table_size )           table.cell ( mode_stat_table , 0 , 2 , ‘Bande di Bollinger’ , text_color = color.gray , bgcolor = #000000 , text_size = table_size ) table.cell ( mode_stat_table , 0 , 3 , ‘Ciclo For’ , text_color = color.gray , bgcolor = #000000 , text_size = table_size ) table.cell ( mode_stat_table , 0 , 4 , ‘Segnale combinato’ , text_color = color.gray , bgcolor = #000000 , text_size = table_size )

    table.cell ( mode_stat_table , 1 , 1 , ‘Segnali:’ , text_color = color.white , bgcolor = #000000 , text_size = table_size )           table.cell ( mode_stat_table , 1 , 2 , bb_score == 1 ? “⬆️Lungo ⬆️” : bb_score == -1 ? “⬇️Breve ⬇️” : na , text_color = pc_bb , bgcolor = #000000 , text_size = table_size ) table.cell ( mode_stat_table , 1 , 3 , fl_score == 1 ? “📈Su 📈” : fl_score == -1 ? “📉Giù 📉” : na , text_color = pc_fl , bgcolor = #000000 , text_size = table_size ) table.cell ( mode_stat_table , 1 , 4 , combined_signal == 1 ? “🚀Trend rialzista 🚀” : combined_signal == -1 ? “🪂Trend ribassista 🪂” : na , text_color = pc_combined , bgcolor = #000000 , text_size = table_size )

    tabella.unione_celle ( modalità_stat_tabella , 0 , 0 , 1 , 0 )    

// Trame

// — Grafico delle bande di Bollinger

plot ( bb_positive_band , color = color.new ( UpC , 50 ) , title = “Banda positiva” , display = display.pane + display.price_scale , force_overlay = true )             

plot ( bb_negative_band , color = color.new ( DnC , 50 ) , title = “Banda negativa” , display = display.pane + display.price_scale , force_overlay = true )             

plot ( avg_bb , color = pc_bb , title = “Media mobile” , force_overlay = true )        

plot ( avg_bb , color = color.new ( pc_bb , 85 ) , title = “Effetto bagliore bande di Bollinger 1” , linewidth = 10 , force_overlay = true , display = display.pane )              

// — Grafico del ciclo For

plot ( mad_fl , color = pc_fl , title = “Ciclo For MAD” )      

plot ( mad_fl , color = color.new ( pc_fl , 75 ) , title = “Effetto bagliore del ciclo For” , linewidth = 10 , display = display.pane )           

plot ( Threshold_L_Fl , color = UpC , title = “Soglia lunga” , display = display.pane )        

plot ( Threshold_S_Fl , color = DnC , title = “Soglia corta” , display = display.pane )       

plotshape ( ta.crossover ( score , 0 ) , title = “Segnale di acquisto” , location = location.belowbar ,    style = shape.labelup , text = “𝓛𝓸𝓷𝓰” , textcolor = #000000 , size = size.small , color = UpC , force_overlay = true , display = display.pane )

plotshape ( ta.crossunder ( score , 0 ) , title = “Segnale di vendita” , location = location.abovebar ,    style = shape.labeldown , text = “𝓢𝓱𝓸𝓻𝓽” , textcolor = #000000 , size = size.small , color = DnC , force_overlay = true , display = display.pane )

barcolor ( pc )

plotcandle ( aperto , alto , basso , chiuso , colore = pc , colore stoppino = pc , colore bordo = pc , force_overlay = true , titolo = “Traccia candela” , display = display.pane )               

// Avvisi

alertcondition ( punteggio == 1 e punteggio [ 1 ] != 1 , “Tendenza deviazione assoluta media – Lunga” , “La tendenza della deviazione assoluta media è lunga {{exchange} }:{{ticker}}” )         

alertcondition ( punteggio == -1 e punteggio [ 1 ] != -1 , “Tendenza deviazione assoluta media – Corta” , “La tendenza della deviazione assoluta media è corta {{exchange }}:{{ticker}}” )