indicatore Mean Deviation Loop

Viewing 3 posts - 1 through 3 (of 3 total)

Author

Posts

02/03/2026 at 11:41 PM #257453 quote

Participant

Junior

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}}” )

02/04/2026 at 4:35 PM #257501 quote

Iván González

Moderator

Master

Ecco qui:

//---------------------------------------------
//PRC_Mean Deviation Loop [Lyro RS]_PRICE
//version = 0
//04.02.2026
//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge
//---------------------------------------------
// --- PARAMETROS ---
//---------------------------------------------
src = close
// Modo senal: 1=Bollinger Bands, 2=For Loop, 3=Combined
signalMode = 3
// Tipo MA: 1=SMA 2=EMA 3=WMA 4=VWMA 5=DEMA 6=TEMA
// 7=RMA 8=HMA 9=LSMA 10=SMMA 11=ZLEMA 12=KAMA 13=T3
// -- Bollinger Bands --
maTypeBB = 2
madLenBB = 25
madMultP = 1.4
madMultN = 1.0
// -- For Loop --
maTypeFL = 2
madLenFL = 10
loopFrom = 10
loopTo = 60
threshLFL = 23
threshSFL = 3
// -- Combined Signal --
threshLC = 0.0
threshSC = 0.0
// -- Colores: 1=Classic 2=Mystic 3=Accented 4=Royal --
colorMode = 2
useCustomCol = 0
custUpR = 0
custUpG = 255
custUpB = 0
custDnR = 255
custDnG = 0
custDnB = 0
// -- Tabla --
showTable = 1

//---------------------------------------------
// SETUP COLORES
//---------------------------------------------
IF colorMode = 1 THEN
   upR = 0
   upG = 230
   upB = 118
   dnR = 136
   dnG = 14
   dnB = 79
ELSIF colorMode = 2 THEN
   upR = 48
   upG = 253
   upB = 207
   dnR = 225
   dnG = 23
   dnB = 183
ELSIF colorMode = 3 THEN
   upR = 150
   upG = 24
   upB = 247
   dnR = 255
   dnG = 0
   dnB = 120
ELSIF colorMode = 4 THEN
   upR = 255
   upG = 193
   upB = 7
   dnR = 103
   dnG = 58
   dnB = 183
ENDIF

IF useCustomCol = 1 THEN
   upR = custUpR
   upG = custUpG
   upB = custUpB
   dnR = custDnR
   dnG = custDnG
   dnB = custDnB
ENDIF

//---------------------------------------------
// PRE-CALCULO: 13 MAs de src con periodo BB
//---------------------------------------------
bbSMA = Average[madLenBB](src)
bbEMA = ExponentialAverage[madLenBB](src)
bbWMA = WeightedAverage[madLenBB](src)
bbVWMA = summation[madLenBB](src * volume) / summation[madLenBB](volume)
bbDEMA = DEMA[madLenBB](src)
bbTEMA = TEMA[madLenBB](src)
bbRMA = WilderAverage[madLenBB](src)
bbHMA = average[madLenBB, 7](src)
bbLSMA = LinearRegression[madLenBB](src)
bbSMMA = WilderAverage[madLenBB](src)
bbZLEMA = average[madLenBB, 8](src)
// KAMA BB (fast=2, slow=30)
IF barindex < madLenBB THEN
   bbKAMA = src
ELSE
   numKbb = abs(src - src[madLenBB])
   denKbb = summation[madLenBB](abs(src - src[1]))
   IF denKbb > 0 THEN
      erKbb = numKbb / denKbb
   ELSE
      erKbb = 0
   ENDIF
   scKbb = erKbb * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
   aKbb = scKbb * scKbb
   bbKAMA = aKbb * src + (1 - aKbb) * bbKAMA[1]
ENDIF
// T3 BB (hot=0.5)
eT1bb = ExponentialAverage[madLenBB](src)
eT2bb = ExponentialAverage[madLenBB](eT1bb)
eT3bb = ExponentialAverage[madLenBB](eT2bb)
eT4bb = ExponentialAverage[madLenBB](eT3bb)
eT5bb = ExponentialAverage[madLenBB](eT4bb)
eT6bb = ExponentialAverage[madLenBB](eT5bb)
bbT3 = -0.125 * eT6bb + 1.125 * eT5bb - 3.375 * eT4bb + 3.375 * eT3bb
//---------------------------------------------
// PRE-CALCULO: 13 MAs de src con periodo FL
//---------------------------------------------
flSMA = Average[madLenFL](src)
flEMA = ExponentialAverage[madLenFL](src)
flWMA = WeightedAverage[madLenFL](src)
flVWMA = summation[madLenFL](src * volume) / summation[madLenFL](volume)
flDEMA = DEMA[madLenFL](src)
flTEMA = TEMA[madLenFL](src)
flRMA = WilderAverage[madLenFL](src)
flHMA = average[madLenFL, 7](src)
flLSMA = LinearRegression[madLenFL](src)
flSMMA = WilderAverage[madLenFL](src)
flZLEMA = average[madLenFL, 8](src)
// KAMA FL
IF barindex < madLenFL THEN
   flKAMA = src
ELSE
   numKfl = abs(src - src[madLenFL])
   denKfl = summation[madLenFL](abs(src - src[1]))
   IF denKfl > 0 THEN
      erKfl = numKfl / denKfl
   ELSE
      erKfl = 0
   ENDIF
   scKfl = erKfl * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
   aKfl = scKfl * scKfl
   flKAMA = aKfl * src + (1 - aKfl) * flKAMA[1]
ENDIF
// T3 FL (hot=0.5)
eT1fl = ExponentialAverage[madLenFL](src)
eT2fl = ExponentialAverage[madLenFL](eT1fl)
eT3fl = ExponentialAverage[madLenFL](eT2fl)
eT4fl = ExponentialAverage[madLenFL](eT3fl)
eT5fl = ExponentialAverage[madLenFL](eT4fl)
eT6fl = ExponentialAverage[madLenFL](eT5fl)
flT3 = -0.125 * eT6fl + 1.125 * eT5fl - 3.375 * eT4fl + 3.375 * eT3fl
//---------------------------------------------
// SELECTOR MA BB
//---------------------------------------------
IF maTypeBB = 1 THEN
   avgBB = bbSMA
ELSIF maTypeBB = 2 THEN
   avgBB = bbEMA
ELSIF maTypeBB = 3 THEN
   avgBB = bbWMA
ELSIF maTypeBB = 4 THEN
   avgBB = bbVWMA
ELSIF maTypeBB = 5 THEN
   avgBB = bbDEMA
ELSIF maTypeBB = 6 THEN
   avgBB = bbTEMA
ELSIF maTypeBB = 7 THEN
   avgBB = bbRMA
ELSIF maTypeBB = 8 THEN
   avgBB = bbHMA
ELSIF maTypeBB = 9 THEN
   avgBB = bbLSMA
ELSIF maTypeBB = 10 THEN
   avgBB = bbSMMA
ELSIF maTypeBB = 11 THEN
   avgBB = bbZLEMA
ELSIF maTypeBB = 12 THEN
   avgBB = bbKAMA
ELSIF maTypeBB = 13 THEN
   avgBB = bbT3
ENDIF
//---------------------------------------------
// SELECTOR MA FL
//---------------------------------------------
IF maTypeFL = 1 THEN
   avgFL = flSMA
ELSIF maTypeFL = 2 THEN
   avgFL = flEMA
ELSIF maTypeFL = 3 THEN
   avgFL = flWMA
ELSIF maTypeFL = 4 THEN
   avgFL = flVWMA
ELSIF maTypeFL = 5 THEN
   avgFL = flDEMA
ELSIF maTypeFL = 6 THEN
   avgFL = flTEMA
ELSIF maTypeFL = 7 THEN
   avgFL = flRMA
ELSIF maTypeFL = 8 THEN
   avgFL = flHMA
ELSIF maTypeFL = 9 THEN
   avgFL = flLSMA
ELSIF maTypeFL = 10 THEN
   avgFL = flSMMA
ELSIF maTypeFL = 11 THEN
   avgFL = flZLEMA
ELSIF maTypeFL = 12 THEN
   avgFL = flKAMA
ELSIF maTypeFL = 13 THEN
   avgFL = flT3
ENDIF
//---------------------------------------------
// MAD CALCULO BB + BANDAS (necesario para scoring BB y Combined)
//---------------------------------------------
madBB = 0
FOR i = 0 TO madLenBB - 1 DO
   madBB = madBB + abs(src[i] - avgBB)
NEXT
madBB = madBB / madLenBB

bbPosBand = avgBB + madBB * madMultP
bbNegBand = avgBB - madBB * madMultN
//---------------------------------------------
// MAD CALCULO FL
//---------------------------------------------
madFL = 0
FOR i = 0 TO madLenFL - 1 DO
   madFL = madFL + abs(src[i] - avgFL)
NEXT
madFL = madFL / madLenFL
//---------------------------------------------
// SERIES DERIVADAS + MAs
//---------------------------------------------
srcXmad = src * madFL

IF maTypeFL = 1 THEN
   maSTM = Average[madLenFL](srcXmad)
   maM2 = Average[madLenFL](madFL)
ELSIF maTypeFL = 2 THEN
   maSTM = ExponentialAverage[madLenFL](srcXmad)
   maM2 = ExponentialAverage[madLenFL](madFL)
ELSIF maTypeFL = 3 THEN
   maSTM = WeightedAverage[madLenFL](srcXmad)
   maM2 = WeightedAverage[madLenFL](madFL)
ELSIF maTypeFL = 4 THEN
   maSTM = summation[madLenFL](srcXmad * volume) / summation[madLenFL](volume)
   maM2 = summation[madLenFL](madFL * volume) / summation[madLenFL](volume)
ELSIF maTypeFL = 5 THEN
   maSTM = DEMA[madLenFL](srcXmad)
   maM2 = DEMA[madLenFL](madFL)
ELSIF maTypeFL = 6 THEN
   maSTM = TEMA[madLenFL](srcXmad)
   maM2 = TEMA[madLenFL](madFL)
ELSIF maTypeFL = 7 THEN
   maSTM = WilderAverage[madLenFL](srcXmad)
   maM2 = WilderAverage[madLenFL](madFL)
ELSIF maTypeFL = 8 THEN
   maSTM = average[madLenFL, 7](srcXmad)
   maM2 = average[madLenFL, 7](madFL)
ELSIF maTypeFL = 9 THEN
   maSTM = LinearRegression[madLenFL](srcXmad)
   maM2 = LinearRegression[madLenFL](madFL)
ELSIF maTypeFL = 10 THEN
   maSTM = WilderAverage[madLenFL](srcXmad)
   maM2 = WilderAverage[madLenFL](madFL)
ELSIF maTypeFL = 11 THEN
   maSTM = average[madLenFL, 8](srcXmad)
   maM2 = average[madLenFL, 8](madFL)
ELSIF maTypeFL = 12 THEN
   // KAMA de series derivadas
   IF barindex < madLenFL THEN
      kamaSTM = srcXmad
      kamaM2 = madFL
   ELSE
      nKs = abs(srcXmad - srcXmad[madLenFL])
      dKs = summation[madLenFL](abs(srcXmad - srcXmad[1]))
      IF dKs > 0 THEN
         erKs = nKs / dKs
      ELSE
         erKs = 0
      ENDIF
      scKs = erKs * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
      aKs = scKs * scKs
      kamaSTM = aKs * srcXmad + (1 - aKs) * kamaSTM[1]
      
      nKm = abs(madFL - madFL[madLenFL])
      dKm = summation[madLenFL](abs(madFL - madFL[1]))
      IF dKm > 0 THEN
         erKm = nKm / dKm
      ELSE
         erKm = 0
      ENDIF
      scKm = erKm * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
      aKm = scKm * scKm
      kamaM2 = aKm * madFL + (1 - aKm) * kamaM2[1]
   ENDIF
   maSTM = kamaSTM
   maM2 = kamaM2
ELSIF maTypeFL = 13 THEN
   // T3 de series derivadas (hot=0.5)
   e1s = ExponentialAverage[madLenFL](srcXmad)
   e2s = ExponentialAverage[madLenFL](e1s)
   e3s = ExponentialAverage[madLenFL](e2s)
   e4s = ExponentialAverage[madLenFL](e3s)
   e5s = ExponentialAverage[madLenFL](e4s)
   e6s = ExponentialAverage[madLenFL](e5s)
   maSTM = -0.125 * e6s + 1.125 * e5s - 3.375 * e4s + 3.375 * e3s
   
   e1m = ExponentialAverage[madLenFL](madFL)
   e2m = ExponentialAverage[madLenFL](e1m)
   e3m = ExponentialAverage[madLenFL](e2m)
   e4m = ExponentialAverage[madLenFL](e3m)
   e5m = ExponentialAverage[madLenFL](e4m)
   e6m = ExponentialAverage[madLenFL](e5m)
   maM2 = -0.125 * e6m + 1.125 * e5m - 3.375 * e4m + 3.375 * e3m
ENDIF

// MAD weighted source
IF maM2 <> 0 THEN
   mwSrc = maSTM / maM2
ELSE
   mwSrc = src
ENDIF

//---------------------------------------------
// FOR LOOP SCORING
//---------------------------------------------
madFLsc = 0
FOR i = loopFrom TO loopTo DO
   IF mwSrc > mwSrc[i] THEN
      madFLsc = madFLsc + 1
   ELSE
      madFLsc = madFLsc - 1
   ENDIF
NEXT

//---------------------------------------------
// SCORING
//---------------------------------------------

// BB Score
IF src CROSSES OVER bbPosBand THEN
   bbScore = 1
ENDIF
IF src CROSSES UNDER bbNegBand THEN
   bbScore = -1
ENDIF

// FL Score
IF madFLsc CROSSES OVER threshLFL THEN
   flScore = 1
ENDIF
IF madFLsc CROSSES UNDER threshSFL THEN
   flScore = -1
ENDIF

// Combined Signal
cSignal = (bbScore + flScore) / 2.0

IF cSignal CROSSES OVER threshLC THEN
   combScore = 1
ENDIF
IF cSignal CROSSES UNDER threshSC THEN
   combScore = -1
ENDIF

// Score final
IF signalMode = 1 THEN
   score = bbScore
ELSIF signalMode = 2 THEN
   score = flScore
ELSIF signalMode = 3 THEN
   score = combScore
ENDIF

//---------------------------------------------
// DETECCION DE SENALES
//---------------------------------------------
longSig = (score = 1 AND score[1] <> 1)
shortSig = (score = -1 AND score[1] <> -1)

//---------------------------------------------
// COLORES
//---------------------------------------------
// Color MA segun bbScore
IF bbScore = 1 THEN
   rBB = upR
   gBB = upG
   bBB = upB
ELSIF bbScore = -1 THEN
   rBB = dnR
   gBB = dnG
   bBB = dnB
ELSE
   rBB = 128
   gBB = 128
   bBB = 128
ENDIF

//---------------------------------------------
// SENALES VISUALES
//---------------------------------------------
atrOff = averagetruerange[14] * 0.5

IF longSig THEN
   DRAWTEXT("▲ Long", barindex, low - atrOff) coloured(upR, upG, upB)
ENDIF
IF shortSig THEN
   DRAWTEXT("▼ Short", barindex, high + atrOff) coloured(dnR, dnG, dnB)
ENDIF

//---------------------------------------------
// TABLA INFORMATIVA
//---------------------------------------------

IF islastbarupdate AND showTable = 1 THEN
   DRAWTEXT("MAD Trend Modes", -200, -30, Dialog, Bold, 12) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) COLOURED(0, 0, 0)
   
   IF bbScore = 1 THEN
      DRAWTEXT("BB: Long ▲", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF bbScore = -1 THEN
      DRAWTEXT("BB: Short ▼", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("BB: ---", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
   
   IF flScore = 1 THEN
      DRAWTEXT("FL: Up ▲", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF flScore = -1 THEN
      DRAWTEXT("FL: Down ▼", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("FL: ---", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
   
   IF combScore = 1 THEN
      DRAWTEXT("Comb: Up-Trend ▲", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF combScore = -1 THEN
      DRAWTEXT("Comb: Down-Trend ▼", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("Comb: ---", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
ENDIF

//---------------------------------------------
// RETURN (bandas + MA sobre precio)
//---------------------------------------------
RETURN avgBB coloured(rBB, gBB, bBB,50) style(line,5) AS "MA", bbPosBand coloured(upR, upG, upB) AS "Upper Band", bbNegBand coloured(dnR, dnG, dnB) AS "Lower Band"

//---------------------------------------------
//PRC_Mean Deviation Loop [Lyro RS]_PANEL
//version = 0
//04.02.2026
//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge
//---------------------------------------------
// --- PARAMETROS ---
//---------------------------------------------
src = close
// Modo senal: 1=Bollinger Bands, 2=For Loop, 3=Combined
signalMode = 3
// Tipo MA: 1=SMA 2=EMA 3=WMA 4=VWMA 5=DEMA 6=TEMA
// 7=RMA 8=HMA 9=LSMA 10=SMMA 11=ZLEMA 12=KAMA 13=T3
// -- Bollinger Bands --
maTypeBB = 2
madLenBB = 25
madMultP = 1.4
madMultN = 1.0
// -- For Loop --
maTypeFL = 2
madLenFL = 10
loopFrom = 10
loopTo = 60
threshLFL = 23
threshSFL = 3
// -- Combined Signal --
threshLC = 0.0
threshSC = 0.0
// -- Colores: 1=Classic 2=Mystic 3=Accented 4=Royal --
colorMode = 2
useCustomCol = 0
custUpR = 0
custUpG = 255
custUpB = 0
custDnR = 255
custDnG = 0
custDnB = 0
// -- Tabla --
showTable = 1

//---------------------------------------------
// SETUP COLORES
//---------------------------------------------
IF colorMode = 1 THEN
   upR = 0
   upG = 230
   upB = 118
   dnR = 136
   dnG = 14
   dnB = 79
ELSIF colorMode = 2 THEN
   upR = 48
   upG = 253
   upB = 207
   dnR = 225
   dnG = 23
   dnB = 183
ELSIF colorMode = 3 THEN
   upR = 150
   upG = 24
   upB = 247
   dnR = 255
   dnG = 0
   dnB = 120
ELSIF colorMode = 4 THEN
   upR = 255
   upG = 193
   upB = 7
   dnR = 103
   dnG = 58
   dnB = 183
ENDIF

IF useCustomCol = 1 THEN
   upR = custUpR
   upG = custUpG
   upB = custUpB
   dnR = custDnR
   dnG = custDnG
   dnB = custDnB
ENDIF

//---------------------------------------------
// PRE-CALCULO: 13 MAs de src con periodo BB
//---------------------------------------------
bbSMA = Average[madLenBB](src)
bbEMA = ExponentialAverage[madLenBB](src)
bbWMA = WeightedAverage[madLenBB](src)
bbVWMA = summation[madLenBB](src * volume) / summation[madLenBB](volume)
bbDEMA = DEMA[madLenBB](src)
bbTEMA = TEMA[madLenBB](src)
bbRMA = WilderAverage[madLenBB](src)
bbHMA = average[madLenBB, 7](src)
bbLSMA = LinearRegression[madLenBB](src)
bbSMMA = WilderAverage[madLenBB](src)
bbZLEMA = average[madLenBB, 8](src)
// KAMA BB (fast=2, slow=30)
IF barindex < madLenBB THEN
   bbKAMA = src
ELSE
   numKbb = abs(src - src[madLenBB])
   denKbb = summation[madLenBB](abs(src - src[1]))
   IF denKbb > 0 THEN
      erKbb = numKbb / denKbb
   ELSE
      erKbb = 0
   ENDIF
   scKbb = erKbb * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
   aKbb = scKbb * scKbb
   bbKAMA = aKbb * src + (1 - aKbb) * bbKAMA[1]
ENDIF
// T3 BB (hot=0.5)
eT1bb = ExponentialAverage[madLenBB](src)
eT2bb = ExponentialAverage[madLenBB](eT1bb)
eT3bb = ExponentialAverage[madLenBB](eT2bb)
eT4bb = ExponentialAverage[madLenBB](eT3bb)
eT5bb = ExponentialAverage[madLenBB](eT4bb)
eT6bb = ExponentialAverage[madLenBB](eT5bb)
bbT3 = -0.125 * eT6bb + 1.125 * eT5bb - 3.375 * eT4bb + 3.375 * eT3bb
//---------------------------------------------
// PRE-CALCULO: 13 MAs de src con periodo FL
//---------------------------------------------
flSMA = Average[madLenFL](src)
flEMA = ExponentialAverage[madLenFL](src)
flWMA = WeightedAverage[madLenFL](src)
flVWMA = summation[madLenFL](src * volume) / summation[madLenFL](volume)
flDEMA = DEMA[madLenFL](src)
flTEMA = TEMA[madLenFL](src)
flRMA = WilderAverage[madLenFL](src)
flHMA = average[madLenFL, 7](src)
flLSMA = LinearRegression[madLenFL](src)
flSMMA = WilderAverage[madLenFL](src)
flZLEMA = average[madLenFL, 8](src)
// KAMA FL
IF barindex < madLenFL THEN
   flKAMA = src
ELSE
   numKfl = abs(src - src[madLenFL])
   denKfl = summation[madLenFL](abs(src - src[1]))
   IF denKfl > 0 THEN
      erKfl = numKfl / denKfl
   ELSE
      erKfl = 0
   ENDIF
   scKfl = erKfl * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
   aKfl = scKfl * scKfl
   flKAMA = aKfl * src + (1 - aKfl) * flKAMA[1]
ENDIF
// T3 FL (hot=0.5)
eT1fl = ExponentialAverage[madLenFL](src)
eT2fl = ExponentialAverage[madLenFL](eT1fl)
eT3fl = ExponentialAverage[madLenFL](eT2fl)
eT4fl = ExponentialAverage[madLenFL](eT3fl)
eT5fl = ExponentialAverage[madLenFL](eT4fl)
eT6fl = ExponentialAverage[madLenFL](eT5fl)
flT3 = -0.125 * eT6fl + 1.125 * eT5fl - 3.375 * eT4fl + 3.375 * eT3fl
//---------------------------------------------
// SELECTOR MA BB
//---------------------------------------------
IF maTypeBB = 1 THEN
   avgBB = bbSMA
ELSIF maTypeBB = 2 THEN
   avgBB = bbEMA
ELSIF maTypeBB = 3 THEN
   avgBB = bbWMA
ELSIF maTypeBB = 4 THEN
   avgBB = bbVWMA
ELSIF maTypeBB = 5 THEN
   avgBB = bbDEMA
ELSIF maTypeBB = 6 THEN
   avgBB = bbTEMA
ELSIF maTypeBB = 7 THEN
   avgBB = bbRMA
ELSIF maTypeBB = 8 THEN
   avgBB = bbHMA
ELSIF maTypeBB = 9 THEN
   avgBB = bbLSMA
ELSIF maTypeBB = 10 THEN
   avgBB = bbSMMA
ELSIF maTypeBB = 11 THEN
   avgBB = bbZLEMA
ELSIF maTypeBB = 12 THEN
   avgBB = bbKAMA
ELSIF maTypeBB = 13 THEN
   avgBB = bbT3
ENDIF
//---------------------------------------------
// SELECTOR MA FL
//---------------------------------------------
IF maTypeFL = 1 THEN
   avgFL = flSMA
ELSIF maTypeFL = 2 THEN
   avgFL = flEMA
ELSIF maTypeFL = 3 THEN
   avgFL = flWMA
ELSIF maTypeFL = 4 THEN
   avgFL = flVWMA
ELSIF maTypeFL = 5 THEN
   avgFL = flDEMA
ELSIF maTypeFL = 6 THEN
   avgFL = flTEMA
ELSIF maTypeFL = 7 THEN
   avgFL = flRMA
ELSIF maTypeFL = 8 THEN
   avgFL = flHMA
ELSIF maTypeFL = 9 THEN
   avgFL = flLSMA
ELSIF maTypeFL = 10 THEN
   avgFL = flSMMA
ELSIF maTypeFL = 11 THEN
   avgFL = flZLEMA
ELSIF maTypeFL = 12 THEN
   avgFL = flKAMA
ELSIF maTypeFL = 13 THEN
   avgFL = flT3
ENDIF
//---------------------------------------------
// MAD CALCULO BB + BANDAS (necesario para scoring BB y Combined)
//---------------------------------------------
madBB = 0
FOR i = 0 TO madLenBB - 1 DO
   madBB = madBB + abs(src[i] - avgBB)
NEXT
madBB = madBB / madLenBB

bbPosBand = avgBB + madBB * madMultP
bbNegBand = avgBB - madBB * madMultN
//---------------------------------------------
// MAD CALCULO FL
//---------------------------------------------
madFL = 0
FOR i = 0 TO madLenFL - 1 DO
   madFL = madFL + abs(src[i] - avgFL)
NEXT
madFL = madFL / madLenFL
//---------------------------------------------
// SERIES DERIVADAS + MAs
//---------------------------------------------
srcXmad = src * madFL

IF maTypeFL = 1 THEN
   maSTM = Average[madLenFL](srcXmad)
   maM2 = Average[madLenFL](madFL)
ELSIF maTypeFL = 2 THEN
   maSTM = ExponentialAverage[madLenFL](srcXmad)
   maM2 = ExponentialAverage[madLenFL](madFL)
ELSIF maTypeFL = 3 THEN
   maSTM = WeightedAverage[madLenFL](srcXmad)
   maM2 = WeightedAverage[madLenFL](madFL)
ELSIF maTypeFL = 4 THEN
   maSTM = summation[madLenFL](srcXmad * volume) / summation[madLenFL](volume)
   maM2 = summation[madLenFL](madFL * volume) / summation[madLenFL](volume)
ELSIF maTypeFL = 5 THEN
   maSTM = DEMA[madLenFL](srcXmad)
   maM2 = DEMA[madLenFL](madFL)
ELSIF maTypeFL = 6 THEN
   maSTM = TEMA[madLenFL](srcXmad)
   maM2 = TEMA[madLenFL](madFL)
ELSIF maTypeFL = 7 THEN
   maSTM = WilderAverage[madLenFL](srcXmad)
   maM2 = WilderAverage[madLenFL](madFL)
ELSIF maTypeFL = 8 THEN
   maSTM = average[madLenFL, 7](srcXmad)
   maM2 = average[madLenFL, 7](madFL)
ELSIF maTypeFL = 9 THEN
   maSTM = LinearRegression[madLenFL](srcXmad)
   maM2 = LinearRegression[madLenFL](madFL)
ELSIF maTypeFL = 10 THEN
   maSTM = WilderAverage[madLenFL](srcXmad)
   maM2 = WilderAverage[madLenFL](madFL)
ELSIF maTypeFL = 11 THEN
   maSTM = average[madLenFL, 8](srcXmad)
   maM2 = average[madLenFL, 8](madFL)
ELSIF maTypeFL = 12 THEN
   // KAMA de series derivadas
   IF barindex < madLenFL THEN
      kamaSTM = srcXmad
      kamaM2 = madFL
   ELSE
      nKs = abs(srcXmad - srcXmad[madLenFL])
      dKs = summation[madLenFL](abs(srcXmad - srcXmad[1]))
      IF dKs > 0 THEN
         erKs = nKs / dKs
      ELSE
         erKs = 0
      ENDIF
      scKs = erKs * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
      aKs = scKs * scKs
      kamaSTM = aKs * srcXmad + (1 - aKs) * kamaSTM[1]
      
      nKm = abs(madFL - madFL[madLenFL])
      dKm = summation[madLenFL](abs(madFL - madFL[1]))
      IF dKm > 0 THEN
         erKm = nKm / dKm
      ELSE
         erKm = 0
      ENDIF
      scKm = erKm * (2.0 / 3.0 - 2.0 / 31.0) + 2.0 / 31.0
      aKm = scKm * scKm
      kamaM2 = aKm * madFL + (1 - aKm) * kamaM2[1]
   ENDIF
   maSTM = kamaSTM
   maM2 = kamaM2
ELSIF maTypeFL = 13 THEN
   // T3 de series derivadas (hot=0.5)
   e1s = ExponentialAverage[madLenFL](srcXmad)
   e2s = ExponentialAverage[madLenFL](e1s)
   e3s = ExponentialAverage[madLenFL](e2s)
   e4s = ExponentialAverage[madLenFL](e3s)
   e5s = ExponentialAverage[madLenFL](e4s)
   e6s = ExponentialAverage[madLenFL](e5s)
   maSTM = -0.125 * e6s + 1.125 * e5s - 3.375 * e4s + 3.375 * e3s
   
   e1m = ExponentialAverage[madLenFL](madFL)
   e2m = ExponentialAverage[madLenFL](e1m)
   e3m = ExponentialAverage[madLenFL](e2m)
   e4m = ExponentialAverage[madLenFL](e3m)
   e5m = ExponentialAverage[madLenFL](e4m)
   e6m = ExponentialAverage[madLenFL](e5m)
   maM2 = -0.125 * e6m + 1.125 * e5m - 3.375 * e4m + 3.375 * e3m
ENDIF

// MAD weighted source
IF maM2 <> 0 THEN
   mwSrc = maSTM / maM2
ELSE
   mwSrc = src
ENDIF

//---------------------------------------------
// FOR LOOP SCORING
//---------------------------------------------
madFLsc = 0
FOR i = loopFrom TO loopTo DO
   IF mwSrc > mwSrc[i] THEN
      madFLsc = madFLsc + 1
   ELSE
      madFLsc = madFLsc - 1
   ENDIF
NEXT

//---------------------------------------------
// SCORING
//---------------------------------------------

// BB Score
IF src CROSSES OVER bbPosBand THEN
   bbScore = 1
ENDIF
IF src CROSSES UNDER bbNegBand THEN
   bbScore = -1
ENDIF

// FL Score
IF madFLsc CROSSES OVER threshLFL THEN
   flScore = 1
ENDIF
IF madFLsc CROSSES UNDER threshSFL THEN
   flScore = -1
ENDIF

// Combined Signal
cSignal = (bbScore + flScore) / 2.0

IF cSignal CROSSES OVER threshLC THEN
   combScore = 1
ENDIF
IF cSignal CROSSES UNDER threshSC THEN
   combScore = -1
ENDIF

// Score final
IF signalMode = 1 THEN
   score = bbScore
ELSIF signalMode = 2 THEN
   score = flScore
ELSIF signalMode = 3 THEN
   score = combScore
ENDIF

//---------------------------------------------
// DETECCION DE SENALES
//---------------------------------------------
longSig = (score = 1 AND score[1] <> 1)
shortSig = (score = -1 AND score[1] <> -1)

//---------------------------------------------
// COLORES
//---------------------------------------------
// Color linea FL segun flScore
IF flScore = 1 THEN
   rFL = upR
   gFL = upG
   bFL = upB
ELSIF flScore = -1 THEN
   rFL = dnR
   gFL = dnG
   bFL = dnB
ELSE
   rFL = 128
   gFL = 128
   bFL = 128
ENDIF

//---------------------------------------------
// SENALES VISUALES
//---------------------------------------------
IF longSig THEN
   DRAWPOINT(barindex, madFLsc, 3) coloured(upR, upG, upB)
ENDIF
IF shortSig THEN
   DRAWPOINT(barindex, madFLsc, 3) coloured(dnR, dnG, dnB)
ENDIF

//---------------------------------------------
// TABLA INFORMATIVA
//---------------------------------------------
IF islastbarupdate AND showTable = 1 THEN
   DRAWTEXT("MAD Trend Modes", -200, -30, Dialog, Bold, 12) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) COLOURED(0, 0, 0)
   
   IF bbScore = 1 THEN
      DRAWTEXT("BB: Long ▲", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF bbScore = -1 THEN
      DRAWTEXT("BB: Short ▼", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("BB: ---", -200, -50, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
   
   IF flScore = 1 THEN
      DRAWTEXT("FL: Up ▲", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF flScore = -1 THEN
      DRAWTEXT("FL: Down ▼", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("FL: ---", -200, -70, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
   
   IF combScore = 1 THEN
      DRAWTEXT("Comb: Up-Trend ▲", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(upR, upG, upB)
   ELSIF combScore = -1 THEN
      DRAWTEXT("Comb: Down-Trend ▼", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(dnR, dnG, dnB)
   ELSE
      DRAWTEXT("Comb: ---", -200, -90, Dialog, Standard, 10) ANCHOR(TOPRIGHT, XSHIFT, YSHIFT) coloured(128, 128, 128)
   ENDIF
ENDIF

//---------------------------------------------
// FILL entre oscilador y cero
//---------------------------------------------
zeroLine = 0
COLORBETWEEN(madFLsc, zeroLine, rFL, gFL, bFL, 40)

//---------------------------------------------
// RETURN (oscilador + thresholds en panel separado)
//---------------------------------------------
RETURN madFLsc coloured(rFL, gFL, bFL) AS "MAD For Loop", threshLFL coloured(upR, upG, upB) AS "Long Threshold", threshSFL coloured(dnR, dnG, dnB) AS "Short Threshold", zeroLine coloured(150, 150, 150) style(dottedline2) AS "Zero"

brian gilbert, robertogozzi and Nicolas thanked this post

02/04/2026 at 8:24 PM #257513 quote

brian gilbert

Participant

Junior

Grazie!! Sei stato grande come al solito… un fulmine!

Author

Posts

Viewing 3 posts - 1 through 3 (of 3 total)

You must be logged in to reply to this topic.

TradingView to ProRealTime Translation Center

New Reply

Author

brian gilbert @brian-gilbert Participant

Summary

This topic contains 2 replies,
has 2 voices, and was last updated by brian gilbert
1 week, 6 days ago.

Topic Details

Forum:	TradingView to ProRealTime Translation Center Forum
Started:	02/03/2026
Status:	Active
Attachments:	No files

Expert Services

No recent search

indicatore Mean Deviation Loop

TradingView to ProRealTime Translation Center

Author

Summary

Topic Details

About personal data collected

Get Assistance

Assistance Type

Your Need

Proposed Solutions

Choose Assistance Type

Your Need

Programming Help

Download Codes

Trading Help

ProRealTime Information

Account Assistance

Paid Programming Help