// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ChartPrime

//@version=5
indicator("MA Multi-Timeframe [ChartPrime]", overlay = true, max_bars_back = 4000, max_polylines_count = 100)

// --------------------------------------------------------------------------------------------------------------------}
// 𝙐𝙎𝙀𝙍 𝙄𝙉𝙋𝙐𝙏𝙎
// --------------------------------------------------------------------------------------------------------------------{

int   length = input.int(20, "Length", inline = "-1")
float source = input.source(close, "", inline = "-1")

string typeMA0 = input.string(title = "MA1 >>", defval = "SMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline ="0")
string typeMA1 = input.string(title = "MA2 >>", defval = "SMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="1")
string typeMA2 = input.string(title = "MA3 >>", defval = "SMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="2")
string typeMA3 = input.string(title = "MA4 >>", defval = "SMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="3")

string ma_tf0 = input.timeframe("360", "",  inline="0")
string ma_tf1 = input.timeframe("D",   "",  inline="1")
string ma_tf2 = input.timeframe("W",   "",  inline="2")
string ma_tf3 = input.timeframe("M",   "",  inline="3")

string styleMA0 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="0")
string styleMA1 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="1")
string styleMA2 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="2")
string styleMA3 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="3")

color color0 = input.color(#1bc6dd, "",  inline="0")
color color1 = input.color(#1b8fdd, "",  inline="1")
color color2 = input.color(#6f1bdd, "",  inline="2")
color color3 = input.color(#dd1bc3, "",  inline="3")

// --------------------------------------------------------------------------------------------------------------------}
// 𝙄𝙉𝘿𝙄𝘾𝘼𝙏𝙊𝙍 𝘾𝘼𝙇𝘾𝙐𝙇𝘼𝙏𝙄𝙊𝙉𝙎
// --------------------------------------------------------------------------------------------------------------------{

request(tf, expression)=>
    request.security(syminfo.tickerid, tf, expression[1], lookahead = barmerge.lookahead_on)

var tbl = table.new(position.top_right, 10, 10,
                     bgcolor      = color.new(color.gray, 90),
                     frame_color  = color.gray,
                     frame_width  = 2,
                     border_color = color.new(color.gray, 80),
                     border_width = 1)

table_cell(row, txt, tf, trend, color)=>
    table.cell(tbl, 0, 0, "MA Type:", text_color = chart.fg_color)
    table.cell(tbl, 1, 0, "Timeframe:", text_color = chart.fg_color)
    table.cell(tbl, 2, 0, "Price:", text_color = chart.fg_color)
    table.cell(tbl, 0, row, "🞛 " + txt, text_color = color)
    table.cell(tbl, 1, row, tf, text_color = color)
    table.cell(tbl, 2, row, trend ? "⮙" : "⮛", text_color = trend ? color.lime : color.fuchsia, text_size = size.large)

ma(tf, color, type, extend, styleMA, cell)=>
    color color_ = color.new(color, 85)

    string style = switch styleMA
        "Solid" => line.style_solid
        "Dashed"=> line.style_dashed
        "Dotted"=> line.style_dotted

    series float expression = switch type
        "SMA" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        "SMMA (RMA)" => ta.rma(source, length)
        "WMA" => ta.wma(source, length)
        "VWMA" => ta.vwma(source, length)

    series float ma = request(tf, expression)

    line.delete(
         line.new(bar_index, ma, bar_index+extend, ma, color = color, style = style)[1]
               )
    line.delete(
         line.new(bar_index, ma, bar_index+extend, ma, color = color_, style = style, width = 5)[1]
               )

    label.delete(
         label.new(bar_index+extend, ma, type + ": " + tf,
                     style = label.style_diamond,
                     color = color_,
                     textcolor = chart.fg_color,
                     size = size.small
                     )[1]
               )
    label.delete(
         label.new(bar_index+extend, ma,
                     style = label.style_diamond,
                     color = color,
                     size = size.tiny
                     )[1]
               )
    if barstate.islast
        cp = array.new<chart.point>()
       
        for i = 0 to 4000
            cp.push(chart.point.from_index(bar_index[i], ma[i]))

        polyline.delete(polyline.new(cp, curved = false, line_color = color, line_style = style)[1])
        polyline.delete(polyline.new(cp, curved = false, line_color = color_, line_style = style, line_width = 5)[1])

        table_cell(cell, type, tf, close > ma, color)

// --------------------------------------------------------------------------------------------------------------------}
// 𝙑𝙄𝙎𝙐𝘼𝙇𝙄𝙕𝘼𝙏𝙄𝙊𝙉
// --------------------------------------------------------------------------------------------------------------------{

ma(ma_tf0, color0, typeMA0, 15, styleMA0, 1)
ma(ma_tf1, color1, typeMA1, 30, styleMA1, 2)
ma(ma_tf2, color2, typeMA2, 45, styleMA2, 3)
ma(ma_tf3, color3, typeMA3, 60, styleMA3, 4)

// --------------------------------------------------------------------------------------------------------------------}

Для лоу

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ChartPrime

//@version=5
indicator("MA Multi-Timeframe [ChartPrime]", overlay = true, max_bars_back = 4000, max_polylines_count = 100)

// --------------------------------------------------------------------------------------------------------------------}
// 𝙐𝙎𝙀𝙍 𝙄𝙉𝙋𝙐𝙏𝙎
// --------------------------------------------------------------------------------------------------------------------{

int   length = input.int(8, "Length", inline = "-1")
float source = input.source(low, "", inline = "-1")

string typeMA0 = input.string(title = "MA1 >>", defval = "VWMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline ="0")
string typeMA1 = input.string(title = "MA2 >>", defval = "VWMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="1")
string typeMA2 = input.string(title = "MA3 >>", defval = "VWMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="2")
string typeMA3 = input.string(title = "MA4 >>", defval = "VWMA", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"], inline="3")

string ma_tf0 = input.timeframe("30", "",  inline="0")
string ma_tf1 = input.timeframe("60",   "",  inline="1")
string ma_tf2 = input.timeframe("240",   "",  inline="2")
string ma_tf3 = input.timeframe("D",   "",  inline="3")

string styleMA0 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="0")
string styleMA1 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="1")
string styleMA2 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="2")
string styleMA3 = input.string(title = "", defval = "Solid", options=["Solid", "Dotted", "Dashed"], inline="3")

color color0 = input.color(color.rgb(236, 38, 38), "",  inline="0")
color color1 = input.color(#ddda1b, "",  inline="1")
color color2 = input.color(#42dd1b, "",  inline="2")
color color3 = input.color(#111011, "",  inline="3")

// --------------------------------------------------------------------------------------------------------------------}
// 𝙄𝙉𝘿𝙄𝘾𝘼𝙏𝙊𝙍 𝘾𝘼𝙇𝘾𝙐𝙇𝘼𝙏𝙄𝙊𝙉𝙎
// --------------------------------------------------------------------------------------------------------------------{

request(tf, expression)=>
    request.security(syminfo.tickerid, tf, expression[1], lookahead = barmerge.lookahead_on)

var tbl = table.new(position.top_right, 10, 10,
                     bgcolor      = color.new(color.gray, 90),
                     frame_color  = color.gray,
                     frame_width  = 2,
                     border_color = color.new(color.gray, 80),
                     border_width = 1)

table_cell(row, txt, tf, trend, color)=>
    table.cell(tbl, 0, 0, "MA Type:", text_color = chart.fg_color)
    table.cell(tbl, 1, 0, "Timeframe:", text_color = chart.fg_color)
    table.cell(tbl, 2, 0, "Price:", text_color = chart.fg_color)
    table.cell(tbl, 0, row, "🞛 " + txt, text_color = color)
    table.cell(tbl, 1, row, tf, text_color = color)
    table.cell(tbl, 2, row, trend ? "⮙" : "⮛", text_color = trend ? color.lime : color.fuchsia, text_size = size.large)

ma(tf, color, type, extend, styleMA, cell)=>
    color color_ = color.new(color, 85)

    string style = switch styleMA
        "Solid" => line.style_solid
        "Dashed"=> line.style_dashed
        "Dotted"=> line.style_dotted

    series float expression = switch type
        "SMA" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        "SMMA (RMA)" => ta.rma(source, length)
        "WMA" => ta.wma(source, length)
        "VWMA" => ta.vwma(source, length)

    series float ma = request(tf, expression)

    line.delete(
         line.new(bar_index, ma, bar_index+extend, ma, color = color, style = style)[1]
               )
    line.delete(
         line.new(bar_index, ma, bar_index+extend, ma, color = color_, style = style, width = 5)[1]
               )

    label.delete(
         label.new(bar_index+extend, ma, type + ": " + tf,
                     style = label.style_diamond,
                     color = color_,
                     textcolor = chart.fg_color,
                     size = size.small
                     )[1]
               )
    label.delete(
         label.new(bar_index+extend, ma,
                     style = label.style_diamond,
                     color = color,
                     size = size.tiny
                     )[1]
               )
    if barstate.islast
        cp = array.new<chart.point>()
       
        for i = 0 to 4000
            cp.push(chart.point.from_index(bar_index[i], ma[i]))

        polyline.delete(polyline.new(cp, curved = false, line_color = color, line_style = style)[1])
        polyline.delete(polyline.new(cp, curved = false, line_color = color_, line_style = style, line_width = 5)[1])

        table_cell(cell, type, tf, close > ma, color)

// --------------------------------------------------------------------------------------------------------------------}
// 𝙑𝙄𝙎𝙐𝘼𝙇𝙄𝙕𝘼𝙏𝙄𝙊𝙉
// --------------------------------------------------------------------------------------------------------------------{

ma(ma_tf0, color0, typeMA0, 15, styleMA0, 1)
ma(ma_tf1, color1, typeMA1, 30, styleMA1, 2)
ma(ma_tf2, color2, typeMA2, 45, styleMA2, 3)
ma(ma_tf3, color3, typeMA3, 60, styleMA3, 4)

// --------------------------------------------------------------------------------------------------------------------}

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © io72signals

//@version=4
study("72s: Linear Weighted Moving Average", shorttitle="LWMA Custom Weighted", overlay=true)

//{ LWMA Custom Weighted Function
get_lwma(src,period, weight) =>
    price = src
    sub = (weight/period)-1
    float p = na
    float d = na
    float sum = 0
    float divider = 0
    for i = 0 to period-1
        p := price[i] * ((weight-i)-sub)
        d := (weight-i)-sub
        sum := sum + p
        divider := divider + d
    sum / divider
//}--LWMA Custom Weighted

/// Sample Usage
lwma_source = input(close, title="LWMA Source:", type=input.source)
lwma_period = input (10, title = "LWMA Lookback Period:", minval=1, step=1)
lwma_weight = input (6, title = "LWMA Weight:", minval=1, step=1)
colorChange = input(true, title="Directional color change?", type=input.bool)

lwma = get_lwma(lwma_source, lwma_period, lwma_weight)

lwmaRise = lwma[1]<lwma
lwmaFall = lwma[1]>lwma
lColor = colorChange? lwmaRise ? color.green : color.red : color.blue

plot(lwma, color=lColor, linewidth=2)

// ALERTS
if lwmaRise and not lwmaRise[1]
    alert("LWMA is Rising", alert.freq_once_per_bar)
if lwmaFall and not lwmaFall[1]
    alert("LWMA is Falling", alert.freq_once_per_bar)

----------------

Самая большая коллекция лучших индикаторов и торговых систем MetaTrader
https://www.best-metatrader-indicators. … cator-mt4/
https://www.best-metatrader-indicators. … indicator/
https://gerchik.com/journal/foreks/chto … trejdinge/
https://ru.tradingview.com/u/LazyBear/# … ed-scripts
https://gerchik.com/journal/foreks/chto … trejdinge/

//+------------------------------------------------------------------+
//|                                       Candle Channel wArrows.mq4 |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1  LimeGreen
#property indicator_color2  Orange
#property indicator_color3  Orange
#property indicator_color4  LimeGreen
#property indicator_color5  Orange
#property indicator_color6  Orange
#property indicator_color7  Green
#property indicator_color8  Red

#property indicator_width1  2
#property indicator_width2  2
#property indicator_width3  2
#property indicator_width4  2
#property indicator_width5  2
#property indicator_width6  2
#property indicator_width7  1
#property indicator_width8  1

int    Price       =  2;
int    Price2      =  3;
int    AdaptPeriod =  1;

extern double Length = 5;
extern bool ShowArrows=true;

double ssm[];
double ssmda[];
double ssmdb[];
double slope[];
double ssm2[];
double ssmda2[];
double ssmdb2[];
double slope2[];
double arr_up[];
double arr_dn[];
//------------------------------------------------------------------
//
//------------------------------------------------------------------
int init()
{
   IndicatorBuffers(10);
   SetIndexBuffer(0,ssm);
   SetIndexBuffer(1,ssmda);
   SetIndexBuffer(2,ssmdb);
   SetIndexBuffer(3,ssm2);
   SetIndexBuffer(4,ssmda2);
   SetIndexBuffer(5,ssmdb2);

   SetIndexBuffer(6, arr_up);
   SetIndexBuffer(7, arr_dn); 

   if(ShowArrows)
   {
      SetIndexStyle(6, DRAW_ARROW);
      SetIndexArrow(6, 233);
      SetIndexStyle(7, DRAW_ARROW);
      SetIndexArrow(7, 234);
   }
   else
   {
      SetIndexStyle(6, DRAW_NONE);
      SetIndexStyle(7, DRAW_NONE);   
   }   
   SetIndexBuffer(8,slope);
   SetIndexBuffer(9,slope2);
   IndicatorShortName ("super smoother");
   return(0);
}
int deinit() { return(0); }

//------------------------------------------------------------------
//
//------------------------------------------------------------------
int start()
{
   int counted_bars=IndicatorCounted();
   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
   int limit = MathMin(Bars-counted_bars,Bars-1);

   int i;
   
   if (slope[limit]==-1) CleanPoint(limit,ssmda,ssmdb);
   for(i=limit; i >= 0; i--)
   {
      double dev = iStdDev(NULL,0,AdaptPeriod,0,MODE_SMA,Price,i);
      double avg = iSma(dev,AdaptPeriod,i,0);
      if (dev!=0)
          double period = Length*avg/dev;
      else          period = Length;
      if (period<3) period = 3;
      ssm[i] = iSmooth(iMA(NULL,0,1,0,MODE_SMA,Price,i),period,i,0);
      ssmda[i] = EMPTY_VALUE;
      ssmdb[i] = EMPTY_VALUE;
      slope[i] = slope[i+1];
      if (ssm[i]>ssm[i+1]) slope[i] =  1;
      if (ssm[i]<ssm[i+1]) slope[i] = -1;
      if (slope[i] == -1) PlotPoint(i,ssmda,ssmdb,ssm);
   }   
   
   if (slope2[limit]==-1) CleanPoint(limit,ssmda2,ssmdb2);
   for(i=limit; i >= 0; i--)
   {
      double dev2 = iStdDev(NULL,0,AdaptPeriod,0,MODE_SMA,Price2,i);
      double avg2 = iSma(dev,AdaptPeriod,i,1);
      if (dev2!=0)
          double period2 = Length*avg2/dev2;
      else          period2 = Length;
      if (period2<3) period2 = 3;
      ssm2[i] = iSmooth(iMA(NULL,0,1,0,MODE_SMA,Price2,i),period2,i,1);
      ssmda2[i] = EMPTY_VALUE;
      ssmdb2[i] = EMPTY_VALUE;
      slope2[i] = slope2[i+1];
      if (ssm2[i]>ssm2[i+1]) slope2[i] =  1;
      if (ssm2[i]<ssm2[i+1]) slope2[i] = -1;
      if (slope2[i] == -1) PlotPoint(i,ssmda2,ssmdb2,ssm2);
   }   

   for(i=limit-1; i>=1; i--)
   {
      int j=i;
      double var1 = 0;
      double var2 = 0;
      for (j = i; j <= i + 9; j++) var2 += MathAbs(iHigh(Symbol(),0,j) - iHigh(Symbol(),0,j));
      var1 = var2 / 10.0;
      arr_up[i] = arr_dn[i] = EMPTY_VALUE;
      double close1=iClose(Symbol(),0,i);
      if(close1>ssm[i])
      {
         arr_up[i]=ssm2[i] - (var1);
      }
      else if(close1<ssm2[i])
      {
         arr_dn[i]=ssm[i] + (var1);
      }
   }     

   return(0);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
double workSmooth[][10];
double iSmooth(double price,int length,int r, int instanceNo=0)
{
   if (ArrayRange(workSmooth,0)!=Bars) ArrayResize(workSmooth,Bars); instanceNo *= 5; r = Bars-r-1;
if(r<=2) { workSmooth[r][instanceNo] = price; workSmooth[r][instanceNo+2] = price; workSmooth[r][instanceNo+4] = price; return(price); }

double alpha = 0.45*(length-1.0)/(0.45*(length-1.0)+2.0);
      workSmooth[r][instanceNo+0] =  price+alpha*(workSmooth[r-1][instanceNo]-price);
     workSmooth[r][instanceNo+1] = (price - workSmooth[r][instanceNo])*(1-alpha)+alpha*workSmooth[r-1][instanceNo+1];
     workSmooth[r][instanceNo+2] =  workSmooth[r][instanceNo+0] + workSmooth[r][instanceNo+1];
     workSmooth[r][instanceNo+3] = (workSmooth[r][instanceNo+2] - workSmooth[r-1][instanceNo+4])*MathPow(1.0-alpha,2) + MathPow(alpha,2)*workSmooth[r-1][instanceNo+3];
     workSmooth[r][instanceNo+4] =  workSmooth[r][instanceNo+3] + workSmooth[r-1][instanceNo+4];
   return(workSmooth[r][instanceNo+4]);
}

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
double workSma[][4];
double iSma(double price, int period, int r, int instanceNo=0)
{
   if (ArrayRange(workSma,0)!= Bars) ArrayResize(workSma,Bars); instanceNo *= 2; r = Bars-r-1;

   workSma[r][instanceNo] = price;
   if (r>=period)
          workSma[r][instanceNo+1] = workSma[r-1][instanceNo+1]+(workSma[r][instanceNo]-workSma[r-period][instanceNo])/period;
   else { workSma[r][instanceNo+1] = 0; for(int k=0; k<period && (r-k)>=0; k++) workSma[r][instanceNo+1] += workSma[r-k][instanceNo]; 
          workSma[r][instanceNo+1] /= k; }
   return(workSma[r][instanceNo+1]);
}

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
void CleanPoint(int i,double& first[],double& second[])
{
   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
        second[i+1] = EMPTY_VALUE;
   else
      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
          first[i+1] = EMPTY_VALUE;
}

void PlotPoint(int i,double& first[],double& second[],double& from[])
{
   if (first[i+1] == EMPTY_VALUE)
      {
         if (first[i+2] == EMPTY_VALUE) {
                first[i]   = from[i];
                first[i+1] = from[i+1];
                second[i]  = EMPTY_VALUE;
            }
         else {
                second[i]   =  from[i];
                second[i+1] =  from[i+1];
                first[i]    = EMPTY_VALUE;
            }
      }
   else
      {
         first[i]  = from[i];
         second[i] = EMPTY_VALUE;
      }
}

//-------------------------------------------------------------------

//@version=6
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$                                                                                 $
//$ Благодарность приветствуется!                                                   $
//$ Gratitude is appreciated!                                                       $
//$                                                                                 $
//$ Вы можете сделать пожертвование через:                                          $
//$ You may donate via:                                                             $
//$                                                                                 $
//$ Крипто-мультивалютный кошелек                                                   $
//$ Crypto-multi-currency wallet                                                    $
//$                                                                                 $
//$ https://tinyurl.com/4f9dr9nw                                                    $
//$                                                                                 $
//$    - BTC: 1EpDN7pg1WqURcK7te5kQtgx3H17wuHiV7                                    $
//$                                                                                 $
//$    - LTC: MJyEtVt7EFmA18Bo1vjRMbguivHnVbbWvp                                    $
//$                                                                                 $
//$ Пожертвуйте столько, сколько считаете нужным.                                   $
//$ Donate as much as you see fit.                                                  $
//$                                                                                 $
//$ Сделайте это, если найдете этот материал полезным!                              $
//$ Do it if you find the stuff useful!                                             $
//$                                                                                 $
//$ Disclaimer: I am not a financial advisor.                                       $
//$ Отказ от ответственности: я не финансовый консультант.                          $
//$                                                                                 $
//$ For purpose educate only. Use at your own risk.                                 $
//$ Только в образовательных целях. Используйте на свой страх и риск.               $
//$                                                                                 $
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

indicator('<[RSI или WPR Bands]>', shorttitle = '<[RSI_WPR_BANDS]>', overlay = true)

// Переключатель
indicatorType = input.string(title = 'Выберите индикатор', defval = 'RSI', options = ['RSI', 'Williams %R'])

// Общие параметры
length = input.int(14, title = 'Длина', minval = 1)

// Уровни RSI
rsi_obLevel = input.int(70, title = 'RSI Уровень перекупленности', minval = 50, maxval = 100)
rsi_osLevel = input.int(30, title = 'RSI Уровень перепроданности', minval = 0, maxval = 50)

// Уровни WPR
wpr_obLevel = input.int(-20, title = 'WPR Уровень перекупленности', minval = -100, maxval = 0)
wpr_osLevel = input.int(-80, title = 'WPR Уровень перепроданности', minval = -100, maxval = 0)

src = close

// --- Расчет RSI Bands ---
ep = 2 * length - 1
auc = ta.ema(math.max(src - src[1], 0), ep)
adc = ta.ema(math.max(src[1] - src, 0), ep)
x1 = (length - 1) * (adc * rsi_obLevel / (100 - rsi_obLevel) - auc)
rsi_ub = x1 >= 0 ? src + x1 : src + x1 * (100 - rsi_obLevel) / rsi_obLevel
x2 = (length - 1) * (adc * rsi_osLevel / (100 - rsi_osLevel) - auc)
rsi_lb = x2 >= 0 ? src + x2 : src + x2 * (100 - rsi_osLevel) / rsi_osLevel
rsi_mid = math.avg(rsi_ub, rsi_lb)

// --- Расчет Williams %R Bands ---
H = ta.highest(high, length)
L = ta.lowest(low, length)
C = close

wpr = -((H - C) / (H - L)) * 100

dist_to_ob = wpr_obLevel - wpr
dist_to_os = wpr - wpr_osLevel

scale = (H - L) / 100

wpr_ub = close + dist_to_ob * scale
wpr_lb = close - dist_to_os * scale
wpr_mid = math.avg(wpr_ub, wpr_lb)

// Вывод в зависимости от выбора
ub = indicatorType == 'RSI' ? rsi_ub : wpr_ub
lb = indicatorType == 'RSI' ? rsi_lb : wpr_lb
mid = indicatorType == 'RSI' ? rsi_mid : wpr_mid

// Цвета для наглядности
plot(ub, title = 'Сопротивление', color = #ff5252, linewidth = 2)
plot(lb, title = 'Поддержка', color = #4caf50, linewidth = 2)
plot(mid, title = 'Midline', color = #787b86, linewidth = 1)

//=================================================================================//

//+------------------------------------------------------------------+
//|                                                   RSI_Bands_LB.mq4 |
//|                        Converted based on LazyBear's RSI Bands   |
//|                                     Fixed display issues         |
//+------------------------------------------------------------------+
#property copyright "Converted based on LazyBear's RSI Bands"
#property link      "https://www.tradingview.com/script/7qnR0LQn-RSI-Bands-LazyBear/"
#property version   "1.40"
#property strict
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 clrRed
#property indicator_color2 clrGreen
#property indicator_color3 clrGray
#property indicator_width1 2
#property indicator_width2 2
#property indicator_width3 1

// Input parameters
input int      Overbought_Level = 70;    // RSI Overbought
input int      Oversold_Level = 30;      // RSI Oversold
input int      RSI_Length = 14;          // RSI Length

// Indicator buffers
double ResistanceBuffer[];
double SupportBuffer[];
double MidlineBuffer[];

// Global variables
int ep;
double alpha;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // Initialize buffers
   SetIndexBuffer(0, ResistanceBuffer);
   SetIndexBuffer(1, SupportBuffer);
   SetIndexBuffer(2, MidlineBuffer);
   
   // Set indicator labels
   SetIndexLabel(0, "Resistance");
   SetIndexLabel(1, "Support");
   SetIndexLabel(2, "RSI Midline");
   
   // Set drawing settings
   IndicatorDigits(Digits);
   int drawBegin = RSI_Length * 2;
   SetIndexDrawBegin(0, drawBegin);
   SetIndexDrawBegin(1, drawBegin);
   SetIndexDrawBegin(2, drawBegin);
   
   // Set EMA period and alpha
   ep = 2 * RSI_Length - 1;
   alpha = 2.0 / (ep + 1.0);
   
   // Initialize as timeseries
   ArraySetAsSeries(ResistanceBuffer, true);
   ArraySetAsSeries(SupportBuffer, true);
   ArraySetAsSeries(MidlineBuffer, true);
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   // Set array directions
   ArraySetAsSeries(close, true);
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   
   // Check for minimum data
   if (rates_total <= ep + 1)
      return(0);
     
   // Calculate starting position
   int start;
   if (prev_calculated == 0)
   {
      // Full recalculation - start from beginning
      start = ep;
   }
   else
   {
      // Only calculate new bars
      start = prev_calculated - 1;
   }

   // Initialize EMA variables for this run
   double auc = 0, adc = 0;
   bool firstCalculation = true;
   
   // Main calculation loop from oldest to newest
   for (int i = start; i >= 0; i--)
   {
      // Skip bars without enough history
      if (i + ep >= rates_total)
      {
         ResistanceBuffer[i] = EMPTY_VALUE;
         SupportBuffer[i] = EMPTY_VALUE;
         MidlineBuffer[i] = EMPTY_VALUE;
         continue;
      }

      // Initialize EMAs on first run
      if (prev_calculated == 0 && firstCalculation)
      {
         firstCalculation = false;
         
         // Calculate initial SMA for AUC
         double sumUp = 0;
         double sumDn = 0;
         for (int j = i; j < i + ep; j++)
         {
            double delta = close[j] - close[j+1];
            sumUp += MathMax(delta, 0);
            sumDn += MathMax(-delta, 0);
         }
         auc = sumUp / ep;
         adc = sumDn / ep;
      }
     
      // Calculate price changes
      double delta = close[i] - close[i+1];
      double up = MathMax(delta, 0);
      double down = MathMax(-delta, 0);
     
      // Update EMAs
      auc = alpha * up + (1 - alpha) * auc;
      adc = alpha * down + (1 - alpha) * adc;
     
      // Avoid division by zero
      double obDivisor = MathMax(100 - Overbought_Level, 0.0001);
      double osDivisor = MathMax(100 - Oversold_Level, 0.0001);
     
      // Calculate bands
      double x1 = (RSI_Length - 1) * (adc * Overbought_Level / obDivisor - auc);
      double ub = (x1 >= 0) ? close[i] + x1 : close[i] + x1 * (100 - Overbought_Level) / Overbought_Level;
     
      double x2 = (RSI_Length - 1) * (adc * Oversold_Level / osDivisor - auc);
      double lb = (x2 >= 0) ? close[i] + x2 : close[i] + x2 * (100 - Oversold_Level) / Oversold_Level;
     
      // Store results
      ResistanceBuffer[i] = ub;
      SupportBuffer[i] = lb;
      MidlineBuffer[i] = (ub + lb) / 2.0;
   }

   return(rates_total);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                     WPR_Bands.mq4|
//+------------------------------------------------------------------+
#property copyright "Based on LazyBear's RSI Bands, adapted for WPR"
#property version   "1.00"

#property strict
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 clrRed
#property indicator_color2 clrGreen
#property indicator_color3 clrGray
#property indicator_width1 2
#property indicator_width2 2
#property indicator_width3 1

input int WPR_Length       = 14;
input int Overbought_Level = -20;
input int Oversold_Level   = -80;

double ResistanceBuffer[];
double SupportBuffer[];
double MidlineBuffer[];

double HighestValue(const double& arr[], int start, int length)
{
   double max_val = arr[start];
   for(int i = start; i < start + length; i++)
      if(arr[i] > max_val) max_val = arr[i];
   return max_val;
}

double LowestValue(const double& arr[], int start, int length)
{
   double min_val = arr[start];
   for(int i = start; i < start + length; i++)
      if(arr[i] < min_val) min_val = arr[i];
   return min_val;
}

int OnInit()
{
   SetIndexBuffer(0, ResistanceBuffer);
   SetIndexBuffer(1, SupportBuffer);
   SetIndexBuffer(2, MidlineBuffer);

   SetIndexLabel(0, "Resistance");
   SetIndexLabel(1, "Support");
   SetIndexLabel(2, "WPR Midline");

   IndicatorDigits(Digits);

   SetIndexDrawBegin(0, WPR_Length);
   SetIndexDrawBegin(1, WPR_Length);
   SetIndexDrawBegin(2, WPR_Length);

   ArraySetAsSeries(ResistanceBuffer, true);
   ArraySetAsSeries(SupportBuffer, true);
   ArraySetAsSeries(MidlineBuffer, true);

   return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   ArraySetAsSeries(close, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);

   if(rates_total < WPR_Length)
      return(0);

   // Цикл от 0 до rates_total - 1, обязательно
   for(int i = 0; i <= rates_total - WPR_Length; i++)
   {
      double highestHigh = HighestValue(high, i, WPR_Length);
      double lowestLow = LowestValue(low, i, WPR_Length);
      double closePrice = close[i];
      double range = highestHigh - lowestLow;

      if(range == 0)
      {
         ResistanceBuffer[i] = EMPTY_VALUE;
         SupportBuffer[i] = EMPTY_VALUE;
         MidlineBuffer[i] = EMPTY_VALUE;
         continue;
      }

      double wpr = -((highestHigh - closePrice) / range) * 100;

      double dist_to_ob = Overbought_Level - wpr;
      double dist_to_os = wpr - Oversold_Level;

      double scale = range / 100.0;

      double ub = closePrice + dist_to_ob * scale;
      double lb = closePrice - dist_to_os * scale;
      double mid = (ub + lb) / 2.0;

      ResistanceBuffer[i] = ub;
      SupportBuffer[i] = lb;
      MidlineBuffer[i] = mid;
   }

   return(rates_total);
}

//@version=3
study(title="Donchain Keltner Channels", shorttitle="DKC", overlay=true)
length = input(20, minval=1)
lower = lowest(length)
upper = highest(length)
basis = avg(upper, lower)
l = plot(lower, color=blue, title="Lower DC")
u = plot(upper, color=blue, title="Upper DC")
plot(basis, color=orange, title="Basis DC")
fill(u, l, color=blue)

useTrueRange = input(true)
length2 = input(20, minval=1)
mult = input(1.0)
src = input(close, title="Source")

ma = ema(src, length2)
range = useTrueRange ? tr : high - low
rangema = ema(range, length2)
upper2 = ma + rangema * mult
lower2 = ma - rangema * mult
c = blue
u2 = plot(upper2, color=c, title="Upper KC")
plot(ma, color=c, title="Basis KC")
l2 = plot(lower2, color=c, title="Lower KC")
fill(u2, l2, color=c)

ENV MTF

https://www.tradingview.com/script/g0io … elope-MTF/

High-Low Difference Channels - SMA/EMA

//@version=2

study(title="High-Low Difference Channels - SMA/EMA", shorttitle="HLDC", overlay=true)

// Revision:    1
// Author:      JayRogers
// Reasoning:   I wrote this up as a potential replacement for my BB based strategies, and so far it's
//              looking pretty nifty.
//
// Description / Usage:
//
//  - Adjust length and multiplier much the same way you would expect with Bollinger Bands.
//  - multiplier of 1 gives you a base channel consisting of one high, and one low sourced SMA (or EMA)
//  - The outer channels are increments of the base channels width, away from the median hl2 sourced SMA (..or EMA)

hlc_length      = input(50, title="Channel Length", minval=1)
hlc_diffMult    = input(1.5, title="Difference Multiplier", minval=0.1, maxval=50)
hlc_useEMA      = input(false, title="Use EMA instead of SMA?")

hl2_line    = hlc_useEMA ? ema(hl2, hlc_length) : sma(hl2, hlc_length)
high_line   = hlc_useEMA ? ema(high, hlc_length) : sma(high, hlc_length)
low_line    = hlc_useEMA ? ema(low, hlc_length) : sma(low, hlc_length)

diffMult(num) =>
    hldm = (high_line - low_line) * hlc_diffMult
    r = hldm * num

midline     = plot(hl2_line, title="Midline", color=silver, transp=0)

highLine    = plot(hl2_line + (diffMult(1) / 2), title="Center Channel Upper", color=silver, transp=100)
lowLine     = plot(hl2_line - (diffMult(1) / 2), title="Center Channel Lower", color=silver, transp=100)

diffUp1     = plot(hl2_line + diffMult(1), title="High Diff 1", color=silver, transp=0)
diffUp2     = plot(hl2_line + diffMult(2), title="High Diff 2", color=silver, transp=0)
diffUp3     = plot(hl2_line + diffMult(3), title="High Diff 3", color=silver, transp=0)

diffDown1   = plot(hl2_line - diffMult(1), title="Low Diff 1", color=silver, transp=0)
diffDown2   = plot(hl2_line - diffMult(2), title="Low Diff 2", color=silver, transp=0)
diffDown3   = plot(hl2_line - diffMult(3), title="Low Diff 3", color=silver, transp=0)

fill(highLine, lowLine, title="Center High-Low Fill", color=silver, transp=50)

1
2
3
//@version=6
3
indicator("Williams Percent Range", shorttitle="Williams %R" format=format.price, precision-2, timeframe= length = input (title="Length", defval=14)
src = input(close, "Source")
_pr(length) =>
4
5
6
max = ta.highest (length)
7
minta.lowest (length)
8
100 * (src max) / (max
min)
9
percentR = _pr(length)
10
obplot = hline(-20, title="Upper Band", color=#787886)
11
12
osPlot = hline(-80, title="Lower Band", color=#787886)
13
14
hline (-50, title="Middle Level", linestyle-hline.style_dotted, color=#787B86)
fill(obPlot, osPlot, title="Background", color-color.rgb(126, 87, 194, 90)) plot(percentR, title="%R", color=#7E57C2)
3
timeframe_gaps=true)

Интервал 1 час

//@version=6
indicator(title="Envelope", shorttitle="Env", overlay=true, timeframe="", timeframe_gaps=true)
len = input.int(3, title="Length", minval=1)
percent = input(0.54, "Percent")
src = input(close, title="Source")
exponential = input(false, "Exponential")
basis = exponential ? ta.ema(src, len) : ta.sma(src, len)
k = percent/100.0
upper = basis * (2 + k)
lower = basis * (2 - k)
plot(basis, "Basis", color=#FF6D00)
u = plot(upper, "Upper", color=#2962FF)
l = plot(lower, "Lower", color=#2962FF)
fill(u, l, color=color.rgb(33, 150, 243, 95), title="Background")

//@version=6
indicator('<[RSI или WPR BandsV2]>', shorttitle='<[RSI_WPR_BANDS2]>', overlay=true, precision=4)

// Переключатель индикатора
indicatorType = input.string('RSI', 'Выберите индикатор', options=['RSI', 'Williams %R'])

// Общие параметры
length = input.int(14, 'Длина', minval=1)

// Уровни RSI
rsi_obLevel = input.int(70, 'RSI Уровень перекупленности', minval=50, maxval=100)
rsi_osLevel = input.int(30, 'RSI Уровень перепроданности', minval=0, maxval=50)

// Уровни WPR (стандартные значения)
wpr_obLevel = input.int(-20, 'WPR Уровень перекупленности', minval=-99, maxval=0)
wpr_osLevel = input.int(-80, 'WPR Уровень перепроданности', minval=-100, maxval=-1)

// Источник данных
src = close

// --- Расчет RSI Bands ---
ep = 2 * length - 1
auc = ta.ema(math.max(src - src[1], 0), ep)
adc = ta.ema(math.max(src[1] - src, 0), ep)

x1 = (length - 1) * (adc * rsi_obLevel / (100 - rsi_obLevel) - auc)
rsi_ub = x1 >= 0 ? src + x1 : src + x1 * (100 - rsi_obLevel) / rsi_obLevel

x2 = (length - 1) * (adc * rsi_osLevel / (100 - rsi_osLevel) - auc)
rsi_lb = x2 >= 0 ? src + x2 : src + x2 * (100 - rsi_osLevel) / rsi_osLevel

rsi_mid = math.avg(rsi_ub, rsi_lb)

// --- Расчет Williams %R Bands ---
H = ta.highest(high, length)
L = ta.lowest(low, length)
C = close

// Защита от деления на ноль + расчет WPR
wpr = H != L ? -((H - C) / (H - L)) * 100 : na

// Расчет полос WPR
price_range = H - L
wpr_ub = H != L ? C + (wpr_obLevel - wpr)/100 * price_range : na
wpr_lb = H != L ? C - (wpr - wpr_osLevel)/100 * price_range : na
wpr_mid = H != L ? math.avg(wpr_ub, wpr_lb) : na

// Выбор отображаемых данных
ub = indicatorType == 'RSI' ? rsi_ub : wpr_ub
lb = indicatorType == 'RSI' ? rsi_lb : wpr_lb
mid = indicatorType == 'RSI' ? rsi_mid : wpr_mid

// Отрисовка линий
plot(ub, 'Сопротивление', #ff5252, 2)
plot(lb, 'Поддержка', #4caf50, 2)
plot(mid, 'Midline', #787b86, 1)

var table logo = table.new(position.bottom_right, 1, 1)
table.cell(logo, 0, 0, 'DM', text_size = size.normal, text_color = #00897b)

//=================================================================================//

//@version=6

indicator('<[MOD_RSI_Bands MTF [LB]>', shorttitle='<[MOD_RSI_BANDS_MTF_LB]>', overlay=true)
// Функция для расчета полос
f_rsi_bands(src, length, obLevel, osLevel) =>
    ep = 2 * length - 1
    auc = ta.ema(math.max(src - src[1], 0), ep)
    adc = ta.ema(math.max(src[1] - src, 0), ep)
    x1 = (length - 1) * (adc * obLevel / (100 - obLevel) - auc)
    ub = x1 >= 0 ? src + x1 : src + x1 * (100 - obLevel) / obLevel
    x2 = (length - 1) * (adc * osLevel / (100 - osLevel) - auc)
    lb = x2 >= 0 ? src + x2 : src + x2 * (100 - osLevel) / osLevel
    [ub, lb]

// ————— ИНДИКАТОР №1 —————
tf1 = input.timeframe("", "Таймфрейм 1", group="Индикатор 1")
obLevel1 = input(70, "RSI Overbought 1", group="Индикатор 1")
osLevel1 = input(30, "RSI Oversold 1", group="Индикатор 1")
length1 = input(14, "RSI Length 1", group="Индикатор 1")
src1 = input(close, "Source 1", group="Индикатор 1")
show1 = input(true, "Показать Индикатор 1", group="Индикатор 1")

// Расчет для МТФ 1
[ub1_current, lb1_current] = f_rsi_bands(src1, length1, obLevel1, osLevel1)
[ub1_mtf, lb1_mtf] = request.security(syminfo.tickerid, tf1, f_rsi_bands(src1, length1, obLevel1, osLevel1))
ub1 = tf1 != "" ? ub1_mtf : ub1_current
lb1 = tf1 != "" ? lb1_mtf : lb1_current

plot(show1 ? ub1 : na, title = 'Resistance 1', color = #ff5252, linewidth = 2)
plot(show1 ? lb1 : na, title = 'Support 1', color = #4caf50, linewidth = 2)
plot(show1 ? math.avg(ub1, lb1) : na, title = 'RSI Midline 1', color = #787b86, linewidth = 1)

// ————— ИНДИКАТОР №2 —————
tf2 = input.timeframe("", "Таймфрейм 2", group="Индикатор 2")
obLevel2 = input(65, "RSI Overbought 2", group="Индикатор 2")
osLevel2 = input(35, "RSI Oversold 2", group="Индикатор 2")
length2 = input(20, "RSI Length 2", group="Индикатор 2")
src2 = input(close, "Source 2", group="Индикатор 2")
show2 = input(true, "Показать Индикатор 2", group="Индикатор 2")

// Расчет для МТФ 2
[ub2_current, lb2_current] = f_rsi_bands(src2, length2, obLevel2, osLevel2)
[ub2_mtf, lb2_mtf] = request.security(syminfo.tickerid, tf2, f_rsi_bands(src2, length2, obLevel2, osLevel2))
ub2 = tf2 != "" ? ub2_mtf : ub2_current
lb2 = tf2 != "" ? lb2_mtf : lb2_current

plot(show2 ? ub2 : na, title = 'Resistance 2', color = #ff9800, linewidth = 2)
plot(show2 ? lb2 : na, title = 'Support 2', color = #2196f3, linewidth = 2)
plot(show2 ? math.avg(ub2, lb2) : na, title = 'RSI Midline 2', color = #9c27b0, linewidth = 1)

// ————— ИНДИКАТОР №3 —————
tf3 = input.timeframe("", "Таймфрейм 3", group="Индикатор 3")
obLevel3 = input(75, "RSI Overbought 3", group="Индикатор 3")
osLevel3 = input(25, "RSI Oversold 3", group="Индикатор 3")
length3 = input(10, "RSI Length 3", group="Индикатор 3")
src3 = input(hl2, "Source 3", group="Индикатор 3")
show3 = input(true, "Показать Индикатор 3", group="Индикатор 3")

// Расчет для МТФ 3
[ub3_current, lb3_current] = f_rsi_bands(src3, length3, obLevel3, osLevel3)
[ub3_mtf, lb3_mtf] = request.security(syminfo.tickerid, tf3, f_rsi_bands(src3, length3, obLevel3, osLevel3))
ub3 = tf3 != "" ? ub3_mtf : ub3_current
lb3 = tf3 != "" ? lb3_mtf : lb3_current

plot(show3 ? ub3 : na, title = 'Resistance 3', color = #880e4f, linewidth = 2)
plot(show3 ? lb3 : na, title = 'Support 3', color = #00897b, linewidth = 2)
plot(show3 ? math.avg(ub3, lb3) : na, title = 'RSI Midline 3', color = #808000, linewidth = 1)

var table logo = table.new(position.bottom_right, 1, 1)
table.cell(logo, 0, 0, 'DM', text_size = size.normal, text_color = #00897b)

//===========================================================================//