Tradingview

z score ile sade tasarım....

PHP Code:

---

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

//@version=5
indicator("Z-Score", overlay=true, max_labels_count = 500)

lengthInput = input.int(50, "Length", minval = 2)
// Calculating High Z Score

a = ta.sma(close, lengthInput)
b = ta.stdev(close, lengthInput)
c = (close - a) / b 



// Highest and Lowest

highz = ta.highest(c, lengthInput)

lowz = ta.lowest(c, lengthInput) 

// Condition Alerts

var wait = 0

wait := wait + 1

if (c <= lowz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="sat", size = size.tiny, color=color.rgb(247, 7, 7))
    alert("sat tepe "+syminfo.ticker, alert.freq_once_per_bar)
    

if (c >= highz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="al", size = size.tiny, color=color.rgb(66, 248, 11))
    alert("al ralli "+syminfo.ticker, alert.freq_once_per_bar)

// Colors

color bear = color.new(color.orange, 0) 
color bull = color.new(color.lime, 0) 

bool overbought = c >= 2 
bool oversold = c <= -2 

brcolor = overbought ? bear : oversold ? bull : na

//barcolor(brcolor)
//////////////////////////
Length22 = input(50)
stddevs = input(1.69)
src22 = close

basis = ta.ema(src22, Length22)

zscore = (src22-basis)/ta.stdev(src22, Length22)

diff = math.abs(src22 - basis)
absZscore = math.abs(zscore)
bounds = diff / absZscore * stddevs
upper = basis + bounds
lower = basis - bounds

zscoreColor = zscore > 0.0 ? zscore >= zscore[1] ? zscore >= stddevs ? color.blue : color.green : color.new(color.green, 70) : zscore <= zscore[1] ? zscore <= -stddevs ? color.blue : color.red : color.new(color.red, 70)

plot(ta.ema(upper, 5), title="Upper ", linewidth=2)
//plot(ta.ema(basis, 5), title="Median", color=color.new(color.white, 60), linewidth=2)
plot(ta.ema(lower, 5), title="Lower ", linewidth=2) 


---

https://www.tradingview.com/x/Yy4GFVZx/

sar stratejisi...

PHP Code:

---

  //@version=5
strategy(title='Parabolic SAR Strategy (on close) [QuantNomad]', shorttitle='SAR Strategy [QN]', overlay=true)

start = input(0.02)
increment = input(0.02)
maximum = input(0.2)
entry_bars = input(1, title='Entry on Nth trend bar')

psar = 0.0  // PSAR
af = 0.0  // Acceleration Factor
trend_dir = 0  // Current direction of PSAR
ep = 0.0  // Extreme point
trend_bars = 0

sar_long_to_short = trend_dir[1] == 1 and close <= psar[1]  // PSAR switches from long to short
sar_short_to_long = trend_dir[1] == -1 and close >= psar[1]  // PSAR switches from short to long

trend_change = barstate.isfirst[1] or sar_long_to_short or sar_short_to_long

// Calculate trend direction
trend_dir := barstate.isfirst[1] and close[1] > open[1] ? 1 : barstate.isfirst[1] and close[1] <= open[1] ? -1 : sar_long_to_short ? -1 : sar_short_to_long ? 1 : nz(trend_dir[1])

trend_bars := sar_long_to_short ? -1 : sar_short_to_long ? 1 : trend_dir == 1 ? nz(trend_bars[1]) + 1 : trend_dir == -1 ? nz(trend_bars[1]) - 1 : nz(trend_bars[1])

// Calculate  Acceleration Factor
af := trend_change ? start : trend_dir == 1 and high > ep[1] or trend_dir == -1 and low < ep[1] ? math.min(maximum, af[1] + increment) : af[1]

// Calculate extreme point
ep := trend_change and trend_dir == 1 ? high : trend_change and trend_dir == -1 ? low : trend_dir == 1 ? math.max(ep[1], high) : math.min(ep[1], low)

// Calculate PSAR
psar := barstate.isfirst[1] and close[1] > open[1] ? low[1] : barstate.isfirst[1] and close[1] <= open[1] ? high[1] : trend_change ? ep[1] : trend_dir == 1 ? psar[1] + af * (ep - psar[1]) : psar[1] - af * (psar[1] - ep)

plot(psar, style=plot.style_cross, color=trend_dir == 1 ? color.green : color.red, linewidth=2)

// Strategy 
strategy.entry('Long', strategy.long, when=trend_bars == entry_bars)
strategy.entry('Short', strategy.short, when=trend_bars == -entry_bars) 


---

sar...

PHP Code:

---

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

//@version=5
indicator('Parabolic SAR', 'SAR', overlay=true)

start = input.float(title='Start', defval=0.02, step=0.001)
increment = input.float(title='Increment', defval=0.02, step=0.001)
maximum = input.float(title='Max Value', defval=0.2, step=0.01)
putlabel = input(title='Put Labels', defval=true)
colup = input.color(title='Colors', defval=color.lime, inline='col')
coldn = input.color(title='', defval=color.red, inline='col')

int trend = 0
float sar = 0.0
float ep = 0.0
float af = 0.0

trend := nz(trend[1])
ep := nz(ep[1])
af := nz(af[1])
sar := sar[1]

if trend == 0 and not na(high[1])
    trend := high >= high[1] or low >= low[1] ? 1 : -1
    sar := trend > 0 ? low[1] : high[1]
    ep := trend > 0 ? high[1] : low[1]
    af := start
    af
else
    nextsar = sar
    if trend > 0
        if high[1] > ep
            ep := high[1]
            af := math.min(maximum, af + increment)
            af

        nextsar := sar + af * (ep - sar)
        nextsar := math.min(math.min(low[1], low[2]), nextsar)

        //Reversal
        if nextsar > low
            trend := -1
            nextsar := ep
            ep := low
            af := start
            af
    else
        if low[1] < ep
            ep := low[1]
            af := math.min(maximum, af + increment)
            af

        nextsar := sar + af * (ep - sar)
        nextsar := math.max(math.max(high[1], high[2]), nextsar)

        //Reversal
        if nextsar < high
            trend := 1
            nextsar := ep
            ep := high
            af := start
            af
    sar := nextsar
    sar

plot(sar, title='Parabolic SAR', color=trend > 0 ? colup : coldn, linewidth=2, style=plot.style_circles)

alertcondition(ta.change(trend) > 0, title='PSAR Trend UP', message='PSAR Trend UP')
alertcondition(ta.change(trend) < 0, title='PSAR Trend DOWN', message='PSAR Trend DOWN')

if ta.change(trend) > 0 and putlabel
    label.new(bar_index, sar, text=str.tostring(math.round_to_mintick(sar)), color=colup, style=label.style_label_up, size=size.tiny)
if ta.change(trend) < 0 and putlabel
    label.new(bar_index, sar, text=str.tostring(math.round_to_mintick(sar)), color=coldn, style=label.style_label_down, size=size.tiny) 


---

sar...

PHP Code:

---

  //@version=5
indicator('Kozlod - Parabolic SAR Strategy Alerts', overlay=true)

// Inputs
start = input(0.02)
increment = input(0.02)
maximum = input(0.2)

// Calculation Parabolic SAR
psar = ta.sar(start, increment, maximum)

// Signals
psar_long = high[1] < psar[2] and high >= psar[1]
psar_short = low[1] > psar[2] and low <= psar[1]

// Plot PSAR
plotshape(psar, location=location.absolute, style=shape.cross, size=size.tiny, color=low <= psar[1] and not psar_long ? color.green : color.red)

// Plot Signals
plotshape(psar_long, title='PSAR Long', text='PSAR Long', style=shape.arrowup, location=location.belowbar, color=color.new(color.blue, 0))
plotshape(psar_short, title='PSAR Short', text='PSAR Short', style=shape.arrowdown, location=location.abovebar, color=color.new(color.red, 0))

// Alerts
alertcondition(psar_long, 'PSAR Long', 'PSAR Long')
alertcondition(psar_short, 'PSAR Short', 'PSAR Short') 


---

atr sar...

PHP Code:

---

  //@version=5
strategy(title='ATR Parabolic SAR Strategy [QuantNomad]', shorttitle='ATR PSAR Strategy [QN]', overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

atr_length = input(14)
start = input(0.02)
increment = input(0.02)
maximum = input(0.2)
entry_bars = input(1, title='Entry on Nth trend bar')

atr = ta.atr(atr_length)

atr := na(atr) ? ta.tr : atr

psar = 0.0  // PSAR
af = 0.0  // Acceleration Factor
trend_dir = 0  // Current direction of PSAR
ep = 0.0  // Extreme point
trend_bars = 0

sar_long_to_short = trend_dir[1] == 1 and close <= psar[1]  // PSAR switches from long to short
sar_short_to_long = trend_dir[1] == -1 and close >= psar[1]  // PSAR switches from short to long

trend_change = barstate.isfirst[1] or sar_long_to_short or sar_short_to_long

// Calculate trend direction
trend_dir := barstate.isfirst[1] and close[1] > open[1] ? 1 : barstate.isfirst[1] and close[1] <= open[1] ? -1 : sar_long_to_short ? -1 : sar_short_to_long ? 1 : nz(trend_dir[1])

trend_bars := sar_long_to_short ? -1 : sar_short_to_long ? 1 : trend_dir == 1 ? nz(trend_bars[1]) + 1 : trend_dir == -1 ? nz(trend_bars[1]) - 1 : nz(trend_bars[1])

// Calculate  Acceleration Factor
af := trend_change ? start : trend_dir == 1 and high > ep[1] or trend_dir == -1 and low < ep[1] ? math.min(maximum, af[1] + increment) : af[1]

// Calculate extreme point
ep := trend_change and trend_dir == 1 ? high : trend_change and trend_dir == -1 ? low : trend_dir == 1 ? math.max(ep[1], high) : math.min(ep[1], low)

// Calculate PSAR
psar := barstate.isfirst[1] and close[1] > open[1] ? low[1] : barstate.isfirst[1] and close[1] <= open[1] ? high[1] : trend_change ? ep[1] : trend_dir == 1 ? psar[1] + af * atr : psar[1] - af * atr

plot(psar, style=plot.style_cross, color=trend_dir == 1 ? color.green : color.red, linewidth=2)


// Strategy 
strategy.entry('Long', strategy.long, when=trend_bars == entry_bars)
strategy.entry('Short', strategy.short, when=trend_bars == -entry_bars) 


---

sar döngülerde...
aynı değerleri farklı periyotlarda döndürme yerine....
test edilen farklı değerleri...
periyotlara uygulayıp....

periyodu döngülemek....

örneğin...
15 dak için belirlenmiş..... https://www.tradingview.com/x/IE3WwZNs/

5 dak için belirlenmiş.... https://www.tradingview.com/x/zw064I5D/

1 dakka için belirlenmiş... https://www.tradingview.com/x/gREnusrx/

şimdi bu döngüler periyotlar için aynı renk olsa...

1 dakkalık beyaz, 5 dakkalık sarı, 15 dakkalık yeşil gibi misal...

ve bu olay... tek bir kodun içine yazılsa....

mtf olmadığı için grafikte bozulma olmaz....

1-5-15 içinde bütün görülmüş olur.....

bu fikri denemek lazım....


ya bu kodla https://tr.tradingview.com/v/fg33yCjb/

ya da https://tr.tradingview.com/v/Zv6fowwF/ bu kodla

çalışarak... deneyelim bakalım....

Alıntı:

---

Originally Posted by @yörük@

sar döngülerde...
aynı değerleri farklı periyotlarda döndürme yerine....
test edilen farklı değerleri...
periyotlara uygulayıp....

periyodu döngülemek....

örneğin...
15 dak için belirlenmiş..... https://www.tradingview.com/x/IE3WwZNs/

5 dak için belirlenmiş.... https://www.tradingview.com/x/zw064I5D/

1 dakka için belirlenmiş... https://www.tradingview.com/x/gREnusrx/

şimdi bu döngüler periyotlar için aynı renk olsa...

1 dakkalık beyaz, 5 dakkalık sarı, 15 dakkalık yeşil gibi misal...

ve bu olay... tek bir kodun içine yazılsa....

mtf olmadığı için grafikte bozulma olmaz....

1-5-15 içinde bütün görülmüş olur.....

bu fikri denemek lazım....


ya bu kodla https://tr.tradingview.com/v/fg33yCjb/

ya da https://tr.tradingview.com/v/Zv6fowwF/ bu kodla

çalışarak... deneyelim bakalım....

---

deneyince sonuçlar şöyle....
1 dakka için kullanılan değerler ve beyaz renkle....
https://i.hizliresim.com/dol6ap0.png

5 dakka için sarı renkle....
https://i.hizliresim.com/aodtoik.png

1 ve 5 dakka beraber ise...
https://i.hizliresim.com/2jwrloj.png

15 dakka fuşya renkle...
https://i.hizliresim.com/7xkejqt.png

1-5 ve 15 dakkanın beraber görünümleri ise
https://i.hizliresim.com/6h4xz16.png
https://i.hizliresim.com/k2sliwu.png
https://i.hizliresim.com/fmgeuaz.png
https://i.hizliresim.com/i9sh4nh.png
https://i.hizliresim.com/5zadac8.png
https://i.hizliresim.com/scljbbb.png

sar ile dip tepe sinyalleri konunca kırılımlara istinaden...

her periyotta iş gören bir tasarım oldu....

periyot seçmek ise kişinin kendi yatırım anlayışına bağlı kalmış oldu....

sadelik içinde diğerlerini gizleyip...istersek değerler kalır...
15 dakkalık fusya ...

görüntüyü belli ediyor....

dikkat ederseniz....
dağınık başlama trendi zayıf....
aynı yerden toplu başlama trendin gücünü ölçmüş gibi oluyor....
https://www.tradingview.com/x/QuBHv3Iv/
https://www.tradingview.com/x/6Ah0hwmu/
https://www.tradingview.com/x/oADdgtIA/
https://www.tradingview.com/x/4pZ1uSIk/
https://www.tradingview.com/x/QIrEiRyH/
https://www.tradingview.com/x/FLdn5Vqp/

1 ve 5 dakkalık gizlenirse......
ama değerler kalırsa....
değerler destekler...dirençler....stop olarak kullanılabileceği gibi.....
sarların başlangıç ve bitiş noktaları ise trend çizgileri veya kanal gibi olur....
https://www.tradingview.com/x/S1t4H5cf/
https://www.tradingview.com/x/PCXMQEnB/
https://www.tradingview.com/x/gQEqKEZb/
https://www.tradingview.com/x/WA7QPVVM/
https://www.tradingview.com/x/9khbCtlM/
https://www.tradingview.com/x/YGzZUcHL/

yedeklemeler....

PHP Code:

---

 // //////////////////////trend hesaplama kısmı////////////////////
//@version=5

indicator('Average Interpercentile Range AIR Supertrend','---', overlay=true, max_labels_count = 500, format=format.price)

// Moving Averages Types
var string SMA      = 'Simple Moving Average'
var string EMA      = 'Exponential Moving Average'
var string WMA      = 'Weighted Moving Average'
var string VWMA     = 'Volume Weighted Moving average'
var string ALMA     = 'Arnaud Legoux Moving Average'
var string JURIK    = 'Jurik Moving Average'
var string T3       = 'Tillson T3 Moving Average'
var string RSIMA    = 'RSI Moving Average'
var string MEDIAN   = 'Median'
var string SS        = 'Super Smoother Moving Average'
var string HANN       = 'Ehlers Hann Moving Average'

src                 = input.source(hl2, title = 'Source', inline = '1')
period              = input.int(title = 'Length', defval = 5, inline = '1')
multiplier          = input.float(title = 'Multiplier', step = 0.1, defval = 3.3, inline = '1')

var string GRP_RF   = '══════ Range mix ══════'
atrActive           = input.bool(true, 'ATR,', inline='42', group=GRP_RF)
atrMult             = input.float(0.3, 'Mult', step=0.1, inline='42', group=GRP_RF)
atr_move            = input.string(T3, 'MA', options=[SMA, EMA, WMA, VWMA, ALMA, JURIK, T3, RSIMA, MEDIAN, SS, HANN], group=GRP_RF, inline='42') 

airActive           = input.bool(true, 'AIR,', inline='44', group=GRP_RF)
airMult             = input.float(0.6, 'Mult', step=0.1, inline='44', group=GRP_RF)
air_move            = input.string(T3, 'MA', options=[SMA, EMA, WMA, VWMA, ALMA, JURIK, T3, RSIMA, MEDIAN, SS, HANN], group=GRP_RF, inline='44') 
spacer              = input.int(16, '%', inline='44', group=GRP_RF)

var string GRP_MA   = 'Global MA Settings'
inputAlmaOffset_T   = input.float(defval = 0.86, title = "Alma Offset", step = 0.01, inline = '1a', group = GRP_MA)
inputAlmaSigma_T    = input.int(defval = 3, title = "... Sigma", inline = '1a', group = GRP_MA)

phase_T             = input.int(defval = 2, title = "Jurik Phase", step = 1, inline = '1j', group = GRP_MA)
power_T             = input.float(defval = 0.9, title = "... Power", step = 0.1, inline = '1j', group = GRP_MA)

fac_t3_T            = input.float(0, step = 0.1, title = 'Tillson T3 Volume Factor', inline = '1t', group = GRP_MA)

var string GRP_UI   = '══════ UI ══════'
up_                 = input.color(#4caf50, '', inline = '2a', group = GRP_UI)
dn_                 = input.color(#ff5252, '', inline = '2a', group = GRP_UI)

bkgrnd              = input.bool(title = 'Fill On/Off ?', defval = true, inline='f', group = GRP_UI)
fader               = input.int(75, 'Fade', inline = 'f', group = GRP_UI)

bar_it              = input.bool(true, 'Color candles On/Off ?', inline = 'f1', group = GRP_UI)
fader_c             = input.int(39, 'Fade', inline = 'f1', group = GRP_UI)

// ===========================================================================================================
//          Functions
// ===========================================================================================================

// @function Jurik Moving Average - TradingView: Moving Averages
Jurik(src, simple int len, jurik_phase, jurik_power) =>
    phaseRatio_l = jurik_phase < -100 ? 0.5 : jurik_phase > 100 ? 2.5 : jurik_phase / 100 + 1.5
    beta_l = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
    alpha_l = math.pow(beta_l, jurik_power)
    jma_l = 0.0
    e0_l = 0.0
    e0_l := (1 - alpha_l) * src + alpha_l * nz(e0_l[1])
    e1_l = 0.0
    e1_l := (src - e0_l) * (1 - beta_l) + beta_l * nz(e1_l[1])
    e2_l = 0.0
    e2_l := (e0_l + phaseRatio_l * e1_l - nz(jma_l[1])) * math.pow(1 - alpha_l, 2) + math.pow(alpha_l, 2) * nz(e2_l[1])
    jma_l := e2_l + nz(jma_l[1])

// @function T3 MA from Tilson3Average © KioseffTrading
t(src, x, a1_t3) =>
    y1 = ta.ema(src,x)
    y2 = ta.ema(y1, x)
    y3 = ta.ema(y2, x)
    y4 = ta.ema(y3, x)
    y5 = ta.ema(y4, x)
    y6 = ta.ema(y5, x)
    v = -a1_t3 * math.pow(a1_t3,2)
    v2 = 3 * math.pow(a1_t3,2) + 3 * math.pow(a1_t3,3)
    v3 = -6 * math.pow(a1_t3, 2) - 3 * a1_t3 - 3 * math.pow(a1_t3, 3)
    v4 = 1 + 3 * a1_t3 + a1_t3 * math.pow(a1_t3, 2) + 3 * math.pow(a1_t3, 2)
    v1 = v * y6 + v2 * y5 + v3 * y4 + v4 * y3
    v1

// Super Smoother Function 
ss(Series, Period) =>  // Super Smoother Function
    var PI = 2.0 * math.asin(1.0)
    var SQRT2 = math.sqrt(2.0)
    lambda = PI * SQRT2 / Period
    a1 = math.exp(-lambda)
    coeff2 = 2.0 * a1 * math.cos(lambda)
    coeff3 = -math.pow(a1, 2.0)
    coeff1 = 1.0 - coeff2 - coeff3
    filt1 = 0.0
    filt1 := coeff1 * (Series + nz(Series[1])) * 0.5 + coeff2 * nz(filt1[1]) + coeff3 * nz(filt1[2])
    filt1

// Hann Window Smoothing – Credits to @cheatcountry
doHannWindow(float _series, float _hannWindowLength) =>
    sum = 0.0, coef = 0.0
    for i = 1 to _hannWindowLength
        cosine = 1 - math.cos(2 * math.pi * i / (_hannWindowLength + 1))
        sum := sum + (cosine * nz(_series[i - 1]))
        coef := coef + cosine
    h = coef != 0 ? sum / coef : 0

// Choose MA type
MA_Calc(_data, _len, MAOption) =>
    value = 
          MAOption == SMA ? ta.sma(_data, _len) : 
          MAOption == EMA ? ta.ema(_data, _len) :
          MAOption == WMA ? ta.wma(_data, _len) : 
          MAOption == VWMA ? ta.vwma(_data, _len) : 
          MAOption == ALMA ? ta.alma(_data, _len, inputAlmaOffset_T, inputAlmaSigma_T) :
          MAOption == JURIK ? Jurik(_data, _len, phase_T, power_T) : 
          MAOption == T3 ? t(_data, _len, fac_t3_T) :
          MAOption == RSIMA ? ta.rma(_data, _len) :
          MAOption == MEDIAN ? ta.median(_data, _len) :
          MAOption == SS ? ss(_data, _len) :
          MAOption == HANN ? doHannWindow(_data, _len) :
      na

ipr_array(len, dnny, uppy) =>
    float[]   hiArray   =   array.new_float (0)
    float[]   loArray   =   array.new_float (0)
    float[]   cmArray   =   array.new_float (0)

    for i = 0 to len - 1
        array.push  (hiArray, high[i])
        array.push  (loArray, low[i])
        array.push  (cmArray, hlcc4[i])

    hlArray     =   array.concat (hiArray, loArray)
    hlcmArray   =   array.concat (hlArray, cmArray)
    
    q1          =   array.percentile_linear_interpolation (hlcmArray, dnny)
    q3          =   array.percentile_linear_interpolation (hlcmArray, uppy)

    iqr = (q3 - q1) / 2

// =================================================================================================
//                                  Calculations
// =================================================================================================

atrFactor   = atrActive ? atrMult * MA_Calc(ta.tr(true), period, atr_move)                             : 0
airFactor   = airActive ? airMult * MA_Calc(ipr_array(period, spacer, 100 - spacer), period, air_move) : 0

blender = nz(atrFactor) + nz(airFactor)

ipr_supertrend(source, len, multi) =>
    up = source - multi * blender
    up1 = nz(up[1], up)
    up := close[1] > up1 ? math.max(up, up1) : up
    dn = source + multi * blender
    dn1 = nz(dn[1], dn)
    dn := close[1] < dn1 ? math.min(dn, dn1) : dn
    trend = 1
    trend := nz(trend[1], trend)
    trend := trend == -1 and close > dn1 ? 1 : trend == 1 and close < up1 ? -1 : trend
    [up, dn, trend]

[upper, lower, supertrend] = ipr_supertrend(src, period, multiplier) 

// =================================================================================================
//                                  Plots
// =================================================================================================

upPlot          = plot(supertrend == 1 ? upper : na, title='+++', style=plot.style_linebr, linewidth=2, color=color.new(up_, 100))
buySignal       = supertrend == 1 and supertrend[1] == -1
dnPlot          = plot(supertrend == 1 ? na : lower, title='---', style=plot.style_linebr, linewidth=2, color=color.new(dn_, 100))
sellSignal      = supertrend == -1 and supertrend[1] == 1

plotshape(buySignal ? upper : na, title='Uptrend Begins', location=location.absolute, style=shape.circle, size=size.small, color=color.new(up_, 0))
plotshape(sellSignal ? lower : na, title='Downtrend Begins', location=location.absolute, style=shape.circle, size=size.small, color=color.new(dn_, 0))

midPlot         = plot(ohlc4, title = '', style = plot.style_circles, display = display.none)
//fill(midPlot, upPlot, title = 'Uptrend Fill', color = bkgrnd ? color.new(up_, fader) : na)
//fill(midPlot, dnPlot, title = 'Downtrend Fill', color = bkgrnd ? color.new(dn_, fader) : na)

color_b         = supertrend == 1 ? up_ : dn_
barcolor(bar_it ? color.new(color_b, fader_c) : na)

// =================================================================================================
//                                  Alerts
// =================================================================================================

alertcondition(buySignal, title='.Supertrend Buy 🟢', message='Supertrend Buy 🟢')
alertcondition(sellSignal, title='.Supertrend Sell 🔴', message='Supertrend Sell 🔴')
changeCond      = supertrend != supertrend[1]
alertcondition(changeCond, title='Supertrend Direction Change 🟢/🔴', message='Supertrend has changed direction 🟢/🔴')


//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length88 = input.int(200, 'Length', minval = 2)
mult88   = input.float(6., 'Factor', minval = 0, step = .5)
tf     = input.timeframe('', 'Timeframe')
src88    = input(close, 'Source')

//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
pred_ranges(length88, mult88)=>
    var avg = src88
    var hold_atr = 0.

    atr = nz(ta.atr(length88)) * mult88
        
    avg := src88 - avg > atr ? avg + atr : 
      avg - src88 > atr ? avg - atr : 
      avg
        
    hold_atr := avg != avg[1] ? atr / 2 : hold_atr
        
    [avg + hold_atr * 2, avg + hold_atr, avg, avg - hold_atr, avg - hold_atr * 2]

//-----------------------------------------------------------------------------}
//Calculation
//-----------------------------------------------------------------------------{
[prR2
  , prR1
  , avg
  , prS1
  , prS2] = request.security(syminfo.tickerid, tf, pred_ranges(length88, mult88))

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot_pru2  = plot(prR2, '+2', avg != avg[1] ? na : #fa071b00)
plot_pru1  = plot(prR1, '+1', avg != avg[1] ? na : #fa071b00)
plot_pravg = plot(avg , '0', avg != avg[1] ? na : #f3f706)
plot_prl1  = plot(prS1, '-1', avg != avg[1] ? na : #04f8cf00)
plot_prl2  = plot(prS2, '-2', avg != avg[1] ? na : #05fcd300)

//Fills
//fill(plot_pru2, plot_pru1, avg != avg[1] ? na : color.new(#f23645, 95))
//fill(plot_prl1, plot_prl2, avg != avg[1] ? na : color.new(#089981, 95))

//-----------------------------------------------------------------------------}
// Custom cosh function
cosh(float x) =>
    (math.exp(x) + math.exp(-x)) / 2

// Custom acosh function
acosh(float x) =>
    x < 1 ? na : math.log(x + math.sqrt(x * x - 1))

// Custom sinh function
sinh(float x) =>
    (math.exp(x) - math.exp(-x)) / 2

// Custom asinh function
asinh(float x) =>
    math.log(x + math.sqrt(x * x + 1))

// Custom inverse tangent function
atan(float x) =>
    math.pi / 2 - math.atan(1 / x)

// Chebyshev Type I Moving Average
chebyshevI(float src, int len, float ripple) =>
    a = 0.
    b = 0.
    g = 0.
    chebyshev = 0.
    
    a := cosh(1 / len * acosh(1 / (1 - ripple)))
    b := sinh(1 / len * asinh(1 / ripple))
    g := (a - b) / (a + b)
    chebyshev := (1 - g) * src + g * nz(chebyshev[1])
    chebyshev

bool_to_float(bool source) =>
    source ? 1 : 0

ema(source)=>
    var float ema = 0.0
    var int count = 0
    count := nz(count[1]) + 1
    ema := (1.0 - 2.0 / (count + 1.0)) * nz(ema[1]) + 2.0 / (count + 1.0) * source
    ema

atan2(y, x) =>
    var float angle = 0.0
    if x > 0
        angle := math.atan(y / x)
    else
        if x < 0 and y >= 0
            angle := math.atan(y / x) + math.pi
        else
            if x < 0 and y < 0
                angle := math.atan(y / x) - math.pi
            else
                if x == 0 and y > 0
                    angle := math.pi / 2
                else
                    if x == 0 and y < 0
                        angle := -math.pi / 2
    angle

degrees(float source) =>
    source * 180 / math.pi

tra()=>
    atr = ema(ta.tr)
    slope = (close - close[10]) / (atr * 10)
    angle_rad = atan2(slope, 1)
    degrees = degrees(angle_rad)
    source = ta.sma((degrees > 0 ? high : low), 2)

mats(source, length) =>
    smooth = 0.
    higher_high = math.max(math.sign(ta.change(ta.highest(length))), 0)
    lower_low = math.max(math.sign(ta.change(ta.lowest(length)) * -1), 0)
    time_constant = math.pow(ta.sma(bool_to_float(higher_high or lower_low), length), 2)
    smooth := nz(smooth[1] + time_constant * (source - smooth[1]), source)

    wilders_period = length * 4 - 1

    atr = math.abs(nz(smooth[1]) - smooth)
    ma_atr = ta.ema(atr, wilders_period)
    delta_fast_atr = ta.ema(ma_atr, wilders_period) * length * 0.4

    result = 0.0
    if smooth > nz(result[1])
        if smooth - delta_fast_atr < result[1]
            result := result[1]
        else
            result := smooth - delta_fast_atr
    else
        if smooth + delta_fast_atr > result[1]
            result := result[1]
        else
            result := smooth + delta_fast_atr

    // Return
    result

length = input.int(30, "Length", 2)
up_color = input.color(color.rgb(2, 139, 250), "", inline = "color")
down_color = input.color(color.rgb(214, 4, 252), "", inline = "color")
enable_glow = input.bool(true, "Enable Glow", inline = "color")

mats = mats(tra(), length)

atr = ta.atr(length)

colour = ta.sma(close, 2) > mats ? up_color : down_color

atr_10 = ema(ta.tr) / 2

alpha = color.new(color.black, 100)

max = mats + atr_10
min = mats - atr_10

center = plot(mats, "!!!", colour, editable = true)
//plot(mats, "Moving Average Trend Sniper", color.new(colour, 70), 2, editable = true)
//plot(mats, "Moving Average Trend Sniper", color.new(colour, 80), 3, editable = true)
//plot(mats, "Moving Average Trend Sniper", color.new(colour, 90), 4, editable = true)

//top = plot(enable_glow ? max : na, "Moving Average Trend Sniper", alpha)
//bottom = plot(enable_glow ? min : na, "Moving Average Trend Sniper", alpha)

//fill(top, center, top_value =  max, bottom_value = mats, bottom_color = color.new(colour, 75), top_color = alpha, editable = true)
//fill(center, bottom, top_value =  mats, bottom_value = min, bottom_color = alpha, top_color = color.new(colour, 75), editable = true) 


---

PHP Code:

---

//@version=5
indicator("Z-Score", overlay= true, scale=scale.none)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            Tooltips                                                                                 ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

t1 = "Determines the Length of Z-Score Assessment. Defaults to a 75 lookback period" 
t2 = "Determines the length of the SMA if the user selects Show SMA. Default is 75, but for a more responsive SMA you can reduce it to 14. Optional."
t3 = "Shows the probability zones in colour." 
t4 = "Will Display a summarized Z-Table." 
t5 = "Display's the SMA."  

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            User Inputs                                                                              ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
len = input.int(75, "Lookback Length", tooltip=t1)
smalen = input.int(75, "SMA Length", tooltip=t2) 
probfill = input.bool(false, "Distribution Probaiblity Fills", tooltip=t3) 
showztable = input.bool(true, "Show Z-Table", tooltip=t4) 
showsma = input.bool(false, "Show SMA", tooltip=t5) 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            Z-Score/SMA Calculations                                                                  ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
z = (close - ta.sma(close, len)) / ta.stdev(close, len) 

cl_sma = ta.sma(close, len) 
cl_sd = ta.stdev(close, len) 

// SMA 
var float z_sma = 0.0 

if showsma 
    z_sma := ta.sma(z, smalen) 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                           Colours                                                                                  ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
color red = color.red 
color green = color.green 
color orange = color.orange 
color yellow = color.yellow 
color labelcolor = color.new(color.white, 100) 
color gray = color.new(color.gray, 25) 
color white = color.white 
// Colour for Probability Distribution 
color greenfill = color.new(color.green, 75) 
color yellowfill = color.new(color.yellow, 75) 
color redfill = color.new(color.red, 75) 


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            Logical Assessments                                                                      ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool zero_one = z >= 0 and z < 1 
bool one_two = z >= 1 and z < 2.01 
bool two_three = z >= 2 and z < 3.01 
bool three = z >= 3 
bool zero = z >= 0.99 and z <= -0.99 
bool neg_zero_one = z < 0 and z > -1 
bool neg_one_two = z <= -1 and z > -2 
bool neg_two_three = z <= -2 and z > -3 
bool neg_three = z <= -3 
falling = ta.falling(z_sma, 3) 
rising = ta.rising(z_sma, 3) 


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                         Plots                                                                                        ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//color z_color_plot = z > 0 ? green : z <= 0 ? red : orange 
plot(z, "Z-Score", color=z > 0 ? color.rgb(76, 175, 79, 100) : z <= 0 ? color.rgb(255, 82, 82, 100) : orange, style=plot.style_line) 
//plot(z_sma, "Z-SMA", color=showsma ? white : labelcolor, linewidth=2) 

neutral = 0 
onesd = 1 
twosd = 2 
threesd = 3 
neg_onesd = -1 
neg_twosd = -2 
neg_threesd = -3 

//a = plot(neutral, color=greenfill)  
//b = plot(onesd, color=yellowfill)  
//c = plot(twosd, color=redfill) 
//d = plot(threesd, color=redfill)  
//e = plot(neg_onesd, color=greenfill)  
//f = plot(neg_twosd, color=yellowfill) 
//g = plot(neg_threesd, color=redfill) 

//fill(a, b, color=probfill ? greenfill : na) 
//fill(b, c, color=probfill ? yellowfill : na) 
//fill(c, d, color=probfill ? redfill : na) 
//fill(a, e, color=probfill ? greenfill : na) 
//fill(e, f, color=probfill ? yellowfill : na) 
//fill(f, g, color=probfill ? redfill : na) 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                           Price Level Calculations                                                                  ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

neutral_price = (cl_sma) + (0 * cl_sd) 
onesd_price = (cl_sma) + (1 * cl_sd) 
twosd_price = (cl_sma) + (2 * cl_sd) 
threesd_price = (cl_sma) + (3 * cl_sd) 
neg_onesd_price = (cl_sma) + (-1 * cl_sd) 
neg_twosd_price = (cl_sma) + (-2 * cl_sd) 
neg_threesd_price = (cl_sma) + (-3 * cl_sd) 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            Line Plots                                                                              ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


var label neutral_price_line = na 
var label onesd_price_line = na
var label twosd_price_line = na 
var label threesd_price_line = na 
var label neg_onesd_price_line = na 
var label neg_twosd_price_line = na 
var label neg_threesd_price_line = na


if bar_index >= 75 
    label.delete(neutral_price_line) 
    label.delete(onesd_price_line) 
    label.delete(twosd_price_line)
    label.delete(threesd_price_line) 
    label.delete(neg_onesd_price_line) 
    label.delete(neg_twosd_price_line)
    label.delete(neg_threesd_price_line) 
    neutral_price_line := label.new(bar_index, y=neutral, text=str.tostring(math.round(neutral_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
    onesd_price_line := label.new(bar_index - 5, onesd, str.tostring(math.round(onesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 
    twosd_price_line := label.new(bar_index - 5, twosd, str.tostring(math.round(twosd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 
    threesd_price_line := label.new(bar_index - 5, threesd, str.tostring(math.round(threesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 
    neg_onesd_price_line := label.new(bar_index - 5, neg_onesd, str.tostring(math.round(neg_onesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 
    neg_twosd_price_line := label.new(bar_index - 5, neg_twosd, str.tostring(math.round(neg_twosd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 
    neg_threesd_price_line := label.new(bar_index - 5, neg_threesd, str.tostring(math.round(neg_threesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right) 


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///                                                            Z-Table                                                                                 ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

var ztable = table.new(position.bottom_center, 10, 3, bgcolor = color.white) 

if showztable 
    // Z-Score / Columns 
    table.cell(ztable, 1, 1, text="Z-Score:", bgcolor = color.white, text_color = color.black) 
    table.cell(ztable, 2, 1, text = "-3", bgcolor = neg_three ? gray : white, text_color=color.black) 
    table.cell(ztable, 3, 1, text="-2", bgcolor = neg_two_three ? gray : white, text_color = color.black) 
    table.cell(ztable, 4, 1, text="-1", bgcolor = neg_zero_one ? gray : white, text_color=color.black) 
    table.cell(ztable, 5, 1, text="0", bgcolor= zero ? gray : white, text_color=color.black) 
    table.cell(ztable, 6, 1, text="1", bgcolor=zero_one ? gray : white, text_color=color.black) 
    table.cell(ztable, 7, 1, text="2", bgcolor=two_three ? gray : white, text_color=color.black) 
    table.cell(ztable, 8, 1, text="3", bgcolor=three ? gray : white, text_color=color.black) 
    // Probability / Rows 
    table.cell(ztable, 1, 2, text="Probability:", bgcolor = color.white, text_color = color.black) 
    table.cell(ztable, 2, 2, text = "0.0013", bgcolor = red, text_color=color.black) 
    table.cell(ztable, 3, 2, text="0.0228", bgcolor = yellow, text_color = color.black) 
    table.cell(ztable, 4, 2, text="0.1600", bgcolor = green, text_color=color.black) 
    table.cell(ztable, 5, 2, text="0.5000", bgcolor=green, text_color=color.black) 
    table.cell(ztable, 6, 2, text="0.8500", bgcolor=green, text_color=color.black) 
    table.cell(ztable, 7, 2, text="0.9800", bgcolor=yellow, text_color=color.black) 
    table.cell(ztable, 8, 2, text="0.9998", bgcolor=red, text_color=color.black) 


---

PHP Code:

---

 // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo

//@version=5
indicator("Predictive Ranges [LuxAlgo]", "***", overlay = true)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length = input.int(200, 'Length', minval = 2)
mult   = input.float(6., 'Factor', minval = 0, step = .5)
tf     = input.timeframe('', 'Timeframe')
src    = input(close, 'Source')

//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
pred_ranges(length, mult)=>
    var avg = src
    var hold_atr = 0.

    atr = nz(ta.atr(length)) * mult
        
    avg := src - avg > atr ? avg + atr : 
      avg - src > atr ? avg - atr : 
      avg
        
    hold_atr := avg != avg[1] ? atr / 2 : hold_atr
        
    [avg + hold_atr * 2, avg + hold_atr, avg, avg - hold_atr, avg - hold_atr * 2]

//-----------------------------------------------------------------------------}
//Calculation
//-----------------------------------------------------------------------------{
[prR2
  , prR1
  , avg
  , prS1
  , prS2] = request.security(syminfo.tickerid, tf, pred_ranges(length, mult))

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot_pru2  = plot(prR2, '+2', avg != avg[1] ? na : #fa071b)
plot_pru1  = plot(prR1, '+1', avg != avg[1] ? na : #fa071b)
plot_pravg = plot(avg , '0', avg != avg[1] ? na : #f3f706)
plot_prl1  = plot(prS1, '-1', avg != avg[1] ? na : #04f8d0)
plot_prl2  = plot(prS2, '-2', avg != avg[1] ? na : #05fcd2)

//Fills
//fill(plot_pru2, plot_pru1, avg != avg[1] ? na : color.new(#f23645, 95))
//fill(plot_prl1, plot_prl2, avg != avg[1] ? na : color.new(#089981, 95))

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


---

PHP Code:

---

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

//@version=5
indicator("Z-Score", overlay=true, max_labels_count = 500)

lengthInput = input.int(50, "Length", minval = 2)
// Calculating High Z Score

a = ta.sma(close, lengthInput)
b = ta.stdev(close, lengthInput)
c = (close - a) / b 



// Highest and Lowest

highz = ta.highest(c, lengthInput)

lowz = ta.lowest(c, lengthInput) 

// Condition Alerts

var wait = 0

wait := wait + 1

if (c <= lowz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="sat", size = size.tiny, color=color.rgb(247, 7, 7))
    alert("sat tepe "+syminfo.ticker, alert.freq_once_per_bar)
    

if (c >= highz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="al", size = size.tiny, color=color.rgb(66, 248, 11))
    alert("al ralli "+syminfo.ticker, alert.freq_once_per_bar)

// Colors

color bear = color.new(color.orange, 0) 
color bull = color.new(color.lime, 0) 

bool overbought = c >= 2 
bool oversold = c <= -2 

brcolor = overbought ? bear : oversold ? bull : na

//barcolor(brcolor)
//////////////////////////
Length22 = input(50)
stddevs = input(1.69)
src22 = close

basis = ta.ema(src22, Length22)

zscore = (src22-basis)/ta.stdev(src22, Length22)

diff = math.abs(src22 - basis)
absZscore = math.abs(zscore)
bounds = diff / absZscore * stddevs
upper = basis + bounds
lower = basis - bounds

zscoreColor = zscore > 0.0 ? zscore >= zscore[1] ? zscore >= stddevs ? color.blue : color.green : color.new(color.green, 70) : zscore <= zscore[1] ? zscore <= -stddevs ? color.blue : color.red : color.new(color.red, 70)

plot(ta.ema(upper, 5), title="Upper ", linewidth=2)
//plot(ta.ema(basis, 5), title="Median", color=color.new(color.white, 60), linewidth=2)
plot(ta.ema(lower, 5), title="Lower ", linewidth=2) 


---

PHP Code:

---

 // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © carefulCode53358
//@version=5
indicator("*", overlay = true, max_boxes_count=100,max_lines_count = 100, max_labels_count = 100, format=format.price)
// Custom cosh function
cosh(float x) =>
    (math.exp(x) + math.exp(-x)) / 2

// Custom acosh function
acosh(float x) =>
    x < 1 ? na : math.log(x + math.sqrt(x * x - 1))

// Custom sinh function
sinh(float x) =>
    (math.exp(x) - math.exp(-x)) / 2

// Custom asinh function
asinh(float x) =>
    math.log(x + math.sqrt(x * x + 1))

// Custom inverse tangent function
atan(float x) =>
    math.pi / 2 - math.atan(1 / x)

// Chebyshev Type I Moving Average
chebyshevI(float src, int len, float ripple) =>
    a = 0.
    b = 0.
    g = 0.
    chebyshev = 0.
    
    a := cosh(1 / len * acosh(1 / (1 - ripple)))
    b := sinh(1 / len * asinh(1 / ripple))
    g := (a - b) / (a + b)
    chebyshev := (1 - g) * src + g * nz(chebyshev[1])
    chebyshev

bool_to_float(bool source) =>
    source ? 1 : 0

ema(source)=>
    var float ema = 0.0
    var int count = 0
    count := nz(count[1]) + 1
    ema := (1.0 - 2.0 / (count + 1.0)) * nz(ema[1]) + 2.0 / (count + 1.0) * source
    ema

atan2(y, x) =>
    var float angle = 0.0
    if x > 0
        angle := math.atan(y / x)
    else
        if x < 0 and y >= 0
            angle := math.atan(y / x) + math.pi
        else
            if x < 0 and y < 0
                angle := math.atan(y / x) - math.pi
            else
                if x == 0 and y > 0
                    angle := math.pi / 2
                else
                    if x == 0 and y < 0
                        angle := -math.pi / 2
    angle

degrees(float source) =>
    source * 180 / math.pi

tra()=>
    atr = ema(ta.tr)
    slope = (close - close[10]) / (atr * 10)
    angle_rad = atan2(slope, 1)
    degrees = degrees(angle_rad)
    source = ta.sma((degrees > 0 ? high : low), 2)

mats(source, length) =>
    smooth = 0.
    higher_high = math.max(math.sign(ta.change(ta.highest(length))), 0)
    lower_low = math.max(math.sign(ta.change(ta.lowest(length)) * -1), 0)
    time_constant = math.pow(ta.sma(bool_to_float(higher_high or lower_low), length), 2)
    smooth := nz(smooth[1] + time_constant * (source - smooth[1]), source)

    wilders_period = length * 4 - 1

    atr = math.abs(nz(smooth[1]) - smooth)
    ma_atr = ta.ema(atr, wilders_period)
    delta_fast_atr = ta.ema(ma_atr, wilders_period) * length * 0.4

    result = 0.0
    if smooth > nz(result[1])
        if smooth - delta_fast_atr < result[1]
            result := result[1]
        else
            result := smooth - delta_fast_atr
    else
        if smooth + delta_fast_atr > result[1]
            result := result[1]
        else
            result := smooth + delta_fast_atr

    // Return
    result

length20 = input.int(5, "Length", 1)

up_color = input.color(color.lime, "", inline = "color")
down_color = input.color(color.red, "", inline = "color")
enable_glow = input.bool(true, "Enable Glow", inline = "color")

mats20 = mats(tra(), length20)


atr20 = ta.atr(length20)


colour20 = ta.sma(close, 1) > mats20 ? up_color : down_color


atr_10 = ema(ta.tr) / 2

alpha = color.new(color.black, 100)

max20 = mats20 + atr_10

min20 = mats20 - atr_10


center20 = plot(mats20, "T0", colour20, style=plot.style_stepline,  editable = true)

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


// User inputs
prd22 = input.int(defval=2, title=' Period for Pivot Points', minval=1, maxval=50)
max_num_of_pivots = input.int(defval=5, title=' Maximum Number of Pivots', minval=5, maxval=10)
max_lines = input.int(defval=1, title=' Maximum number of trend lines', minval=1, maxval=10)
show_lines = input.bool(defval=true, title=' Show trend lines')
show_pivots = input.bool(defval=true, title=' Show Pivot Points')

float ph = ta.pivothigh(high, prd22, prd22)
float pl = ta.pivotlow(low, prd22, prd22)

//plotshape(ph and show_pivots, style=shape.triangledown, location=location.abovebar, offset=-prd22, size=size.small)
//plotshape(pl and show_pivots, style=shape.triangleup, location=location.belowbar, offset=-prd22, size=size.small)

// Creating array of pivots
var pivots_high = array.new_float(0)
var pivots_low = array.new_float(0)

var high_ind = array.new_int(0)
var low_ind = array.new_int(0)

if ph 
    array.push(pivots_high, ph)
    array.push(high_ind, bar_index - prd22)
    if array.size(pivots_high) > max_num_of_pivots  // limit the array size
        array.shift(pivots_high)
        array.shift(high_ind)

if pl
    array.push(pivots_low, pl)
    array.push(low_ind, bar_index - prd22)
    if array.size(pivots_low) > max_num_of_pivots  // limit the array size
        array.shift(pivots_low)
        array.shift(low_ind)

// Create arrays to store slopes and lines
var res_lines = array.new_line()
var res_slopes = array.new_float()

len_lines = array.size(res_lines)

if (len_lines >= 1)
    for ind = 0 to len_lines - 1 
        to_delete = array.pop(res_lines)
        array.pop(res_slopes)
        line.delete(to_delete)
        // line.set_extend(to_delete, extend=extend.none)



count_slope(ph1, ph2, pos1, pos2) => (ph2 - ph1) / (pos2 - pos1)


if array.size(pivots_high) == max_num_of_pivots
    index_of_biggest_slope = 0
    for ind1 = 0 to max_num_of_pivots - 2
        for ind2 = ind1 + 1 to max_num_of_pivots - 1
            p1 = array.get(pivots_high, ind1)
            p2 = array.get(pivots_high, ind2)
            pos1 = array.get(high_ind, ind1)
            pos2 = array.get(high_ind, ind2)
            k = count_slope(p1, p2, pos1, pos2)
            b = p1 - k * pos1

            // ok = k * bar_index + b > high
            ok = true
            // label.new(pos1, p1, str.tostring(ok))
            for ind3 = ind2 to max_num_of_pivots - 1
                p3 = array.get(pivots_high, ind3)
                pos3 = array.get(high_ind, ind3)
                if p3 > k * pos3 + b 
                    ok := false
                    // label.new(pos3, p3, 'cross')
                    break

            if ind2 - ind1 >= 1
                for ind3 = ind1 + 1 to ind2 - 1
                    p3 = array.get(pivots_high, ind3)
                    pos3 = array.get(high_ind, ind3)
                    if p3 > k * pos3 + b 
                        ok := false
                        // label.new(pos3, p3, 'cross')
                        break

            for ind = 0 to prd22 - 1
                if high[ind] * 0.996 > k * bar_index[ind] + b
                    ok := false
                    break
            
            
            if ok //and not (high > k * bar_index + b) // 'and not' for the last line to check if the crosses the price action
                if array.size(res_slopes) < max_lines // max_lines // for now only 1 lines is to be shown
                    line = line.new(pos1, p1, pos2, p2, extend=extend.right)
                    array.push(res_lines, line)
                    array.push(res_slopes, k)  
                else
                    max_slope = array.max(res_slopes)
                    max_slope_ind = array.indexof(res_slopes, max_slope)
                    if max_lines == 1
                        max_slope_ind := 0
                    if k < max_slope
                        line_to_delete = array.get(res_lines, max_slope_ind)
                        line.delete(line_to_delete) 
                        new_line = line.new(pos1, p1, pos2, p2, extend=extend.right)
                        array.insert(res_lines, max_slope_ind, new_line)
                        array.insert(res_slopes, max_slope_ind, k)
                        array.remove(res_lines, max_slope_ind + 1)
                        array.remove(res_slopes, max_slope_ind + 1)
                        // label.new(pos1, p1, str.tostring(res_slopes))

// if barstate.islast
//     label.new(bar_index, high, str.tostring(array.size(res_lines)))

if array.size(res_lines) >= 1 and barstate.islast
    for ind=0 to array.size(res_lines) - 1 
        l = array.get(res_lines, ind)
        s = array.get(res_slopes, ind)
        x1 = line.get_x1(l)
        x2 = line.get_x2(l) 
        prev_lable_ind = 0//x2 + prd - 5
        for ind1=x2 to bar_index
            p = line.get_price(l, ind1) 
            if (math.abs(p - high[bar_index - ind1]) < p * 0.005) 
                if ind1 - prev_lable_ind > 10 and ind1 - x2 >= prd22
                    //label.new(ind1, high[bar_index - ind1], text='S', style=label.style_label_down, color=color.red)
                    prev_lable_ind := ind1

if not show_lines
    len_l = array.size(res_lines)
    if (len_l >= 1)
        for ind = 0 to len_l - 1 
            to_delete = array.pop(res_lines)
            array.pop(res_slopes)
            line.delete(to_delete)

var sup_lines = array.new_line()
var sup_slopes = array.new_float()

len_lines1 = array.size(sup_lines)

if (len_lines1 >= 1)
    for ind = 0 to len_lines1 - 1 
        to_delete = array.pop(sup_lines)
        array.pop(sup_slopes)
        line.delete(to_delete)

if array.size(pivots_low) == max_num_of_pivots
    for ind1 = 0 to max_num_of_pivots - 2
        for ind2 = ind1 + 1 to max_num_of_pivots - 1
            p1 = array.get(pivots_low, ind1)
            p2 = array.get(pivots_low, ind2)
            pos1 = array.get(low_ind, ind1)
            pos2 = array.get(low_ind, ind2)
            k = count_slope(p1, p2, pos1, pos2)
            b = p1 - k * pos1

            // check if pivot points in the future are lower than the line between two points 
            ok = true
            for ind3 = ind2 to max_num_of_pivots - 1
                p3 = array.get(pivots_low, ind3)
                pos3 = array.get(low_ind, ind3)
                if p3 < k * pos3 + b
                    ok := false
                    // label.new(pos3, p3, 'cross')
                    break

            // check if pivot points in the middle of two points is lower
            if ind2 - ind1 >= 1
                for ind3 = ind1 + 1 to ind2 - 1
                    p3 = array.get(pivots_low, ind3)
                    pos3 = array.get(low_ind, ind3)
                    if p3 < k * pos3 + b
                        ok := false
                        // label.new(pos3, p3, 'cross')
                        break
            
            for ind = 0 to prd22 - 2
                if low[ind] * 1.008 < k * bar_index[ind] + b
                    ok := false
                    break
            
            if ok //and not (low < k * bar_index + b) // 'and not' for the last line to check if the it crosses the price action
                if array.size(sup_slopes) < max_lines // max_lines // for now only 1 lines is to be shown
                    line = line.new(pos1, p1, pos2, p2, extend=extend.right)
                    // label.new(pos1, p1, 'ok to print')
                    array.push(sup_lines, line)
                    array.push(sup_slopes, k)  
                else
                    max_slope = array.min(sup_slopes)
                    max_slope_ind = array.indexof(sup_slopes, max_slope)
                    if max_lines == 1
                        max_slope_ind := 0
                    if k > max_slope
                        line_to_delete = array.get(sup_lines, max_slope_ind)
                        line.delete(line_to_delete) 
                        new_line = line.new(pos1, p1, pos2, p2, extend=extend.right)
                        array.insert(sup_lines, max_slope_ind, new_line)
                        array.insert(sup_slopes, max_slope_ind, k)
                        array.remove(sup_lines, max_slope_ind + 1)
                        array.remove(sup_slopes, max_slope_ind + 1)
                        // label.new(pos1, p1, str.tostring(sup_slopes))


if array.size(sup_lines) >= 1 and barstate.islast
    for ind=0 to array.size(sup_lines) - 1 
        l = array.get(sup_lines, ind)
        s = array.get(sup_slopes, ind)
        x1 = line.get_x1(l)
        x2 = line.get_x2(l) 
        prev_lable_ind = 0//x2 + prd - 5
        for ind1=x2 to bar_index
            p = line.get_price(l, ind1) 
            if (math.abs(p - low[bar_index - ind1]) < p * 0.005) 
                if ind1 - prev_lable_ind > 10 and ind1 - x2 >= prd22
                    //label.new(ind1, low[bar_index - ind1], text='A', style=label.style_label_up, color=color.green)
                    prev_lable_ind := ind1

if not show_lines
    len_l = array.size(sup_lines)
    if (len_l >= 1)
        for ind = 0 to len_l - 1 
            to_delete = array.pop(sup_lines)
            array.pop(sup_slopes)
            line.delete(to_delete)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//Settings
//-----------------------------------------------------------------------------{
length = input.int(200, 'Length', minval = 2)
mult   = input.float(6., 'Factor', minval = 0, step = .5)
tf     = input.timeframe('', 'Timeframe')
src    = input(close, 'Source')

//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
pred_ranges(length, mult)=>
    var avg = src
    var hold_atr = 0.

    atr = nz(ta.atr(length)) * mult
        
    avg := src - avg > atr ? avg + atr : 
      avg - src > atr ? avg - atr : 
      avg
        
    hold_atr := avg != avg[1] ? atr / 2 : hold_atr
        
    [avg + hold_atr * 2, avg + hold_atr, avg, avg - hold_atr, avg - hold_atr * 2]

//-----------------------------------------------------------------------------}
//Calculation
//-----------------------------------------------------------------------------{
[prR2
  , prR1
  , avg
  , prS1
  , prS2] = request.security(syminfo.tickerid, tf, pred_ranges(length, mult))

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot_pru2  = plot(prR2, '+RH2', avg != avg[1] ? na : #f2364600)
plot_pru1  = plot(prR1, '+RH1', avg != avg[1] ? na : #f2364600)
plot_pravg = plot(avg , 'RH0', avg != avg[1] ? na : #f3f70700)
plot_prl1  = plot(prS1, '-RH1', avg != avg[1] ? na : #08998100)
plot_prl2  = plot(prS2, '-RH2', avg != avg[1] ? na : #08998100)

//Fills
fill(plot_pru2, plot_pru1, avg != avg[1] ? na : color.new(#f23645,55))
fill(plot_prl1, plot_prl2, avg != avg[1] ? na : color.new(#089981, 55))

//-----------------------------------------------------------------------------}
//Settings
//-----------------------------------------------------------------------------{
length33      = input.int(70
  , minval = 0)

extrapolate = input.int(10
  , minval = 0)

degree      = input.int(3, 'Polynomial Degree'
  , minval = 0
  , maxval = 8)

src33         = input(close)

lock        = input(false, 'Lock Forecast')

//Style
up_css = input.color(#0cb51a, 'Upward Color'
  , group = 'Style')
  
dn_css = input.color(#ff1100, 'Downward Color'
  , group = 'Style')

ex_css = input.color(#ea00ff, 'Extrapolation Color'
  , group = 'Style')
  
width  = input(3, 'Width'
  , group = 'Style')

//-----------------------------------------------------------------------------}
//Fill lines array
//-----------------------------------------------------------------------------{
var lines = array.new_line(0)

if barstate.isfirst
    for i = -extrapolate to length33-1
        array.push(lines, line.new(na, na, na, na))

//-----------------------------------------------------------------------------}
//Get design matrix & partially solve system
//-----------------------------------------------------------------------------{
n33 = bar_index

var design   = matrix.new<float>(0, 0)
var response = matrix.new<float>(0, 0)

if barstate.isfirst
    for i = 0 to degree
        column = array.new_float(0)
        
        for j = 0 to length33-1
            array.push(column, math.pow(j,i))
        
        matrix.add_col(design, i, column)

var a = matrix.inv(matrix.mult(matrix.transpose(design), design))
var b = matrix.mult(a, matrix.transpose(design))

//-----------------------------------------------------------------------------}
//Get response matrix and compute roling polynomial regression
//-----------------------------------------------------------------------------{
var pass = 1
var matrix<float> coefficients = na
var x = -extrapolate
var float forecast = na

if barstate.islast 
    if pass
        prices = array.new_float(0)
        
        for i = 0 to length33-1
            array.push(prices, src33[i])
        
        matrix.add_col(response, 0, prices)
        
        coefficients := matrix.mult(b, response)
        
        float y1 = na
        idx = 0
        
        for i = -extrapolate to length33-1
            y2 = 0.
            
            for j = 0 to degree
                y2 += math.pow(i, j)*matrix.get(coefficients, j, 0)
            
            if idx == 0
                forecast := y2
                
            //------------------------------------------------------------------
            //Set lines
            //------------------------------------------------------------------
            css33 = y2 < y1 ? up_css : dn_css
            
            get_line = array.get(lines, idx)
            
            line.set_xy1(get_line, n33 - i + 1, y1)
            
            line.set_xy2(get_line, n33 - i, y2)
            
            line.set_color(get_line, i <= 0 ? ex_css : css33)
            
            line.set_width(get_line, width)
            
            y1 := y2
            idx += 1
            
        if lock
            pass := 0
    else
        y2 = 0.
        x -= 1
        
        for j = 0 to degree
            y2 += math.pow(x, j)*matrix.get(coefficients, j, 0)
        
        forecast := y2

plot(pass == 0 ? forecast : na, 'Extrapolation'
  , color     = ex_css
  , offset    = extrapolate
  , linewidth = width)

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


---

PHP Code:

---

  // //////////////////////trend hesaplama kısmı////////////////////
//@version=5

indicator('Average Interpercentile Range AIR Supertrend','---', overlay=true, format=format.price)

// Moving Averages Types
var string SMA      = 'Simple Moving Average'
var string EMA      = 'Exponential Moving Average'
var string WMA      = 'Weighted Moving Average'
var string VWMA     = 'Volume Weighted Moving average'
var string ALMA     = 'Arnaud Legoux Moving Average'
var string JURIK    = 'Jurik Moving Average'
var string T3       = 'Tillson T3 Moving Average'
var string RSIMA    = 'RSI Moving Average'
var string MEDIAN   = 'Median'
var string SS        = 'Super Smoother Moving Average'
var string HANN       = 'Ehlers Hann Moving Average'

src                 = input.source(hl2, title = 'Source', inline = '1')
period              = input.int(title = 'Length', defval = 5, inline = '1')
multiplier          = input.float(title = 'Multiplier', step = 0.1, defval = 3.3, inline = '1')

var string GRP_RF   = '══════ Range mix ══════'
atrActive           = input.bool(true, 'ATR,', inline='42', group=GRP_RF)
atrMult             = input.float(0.3, 'Mult', step=0.1, inline='42', group=GRP_RF)
atr_move            = input.string(T3, 'MA', options=[SMA, EMA, WMA, VWMA, ALMA, JURIK, T3, RSIMA, MEDIAN, SS, HANN], group=GRP_RF, inline='42') 

airActive           = input.bool(true, 'AIR,', inline='44', group=GRP_RF)
airMult             = input.float(0.6, 'Mult', step=0.1, inline='44', group=GRP_RF)
air_move            = input.string(T3, 'MA', options=[SMA, EMA, WMA, VWMA, ALMA, JURIK, T3, RSIMA, MEDIAN, SS, HANN], group=GRP_RF, inline='44') 
spacer              = input.int(16, '%', inline='44', group=GRP_RF)

var string GRP_MA   = 'Global MA Settings'
inputAlmaOffset_T   = input.float(defval = 0.86, title = "Alma Offset", step = 0.01, inline = '1a', group = GRP_MA)
inputAlmaSigma_T    = input.int(defval = 3, title = "... Sigma", inline = '1a', group = GRP_MA)

phase_T             = input.int(defval = 2, title = "Jurik Phase", step = 1, inline = '1j', group = GRP_MA)
power_T             = input.float(defval = 0.9, title = "... Power", step = 0.1, inline = '1j', group = GRP_MA)

fac_t3_T            = input.float(0, step = 0.1, title = 'Tillson T3 Volume Factor', inline = '1t', group = GRP_MA)

var string GRP_UI   = '══════ UI ══════'
up_                 = input.color(#4caf50, '', inline = '2a', group = GRP_UI)
dn_                 = input.color(#ff5252, '', inline = '2a', group = GRP_UI)

bkgrnd              = input.bool(title = 'Fill On/Off ?', defval = true, inline='f', group = GRP_UI)
fader               = input.int(75, 'Fade', inline = 'f', group = GRP_UI)

bar_it              = input.bool(true, 'Color candles On/Off ?', inline = 'f1', group = GRP_UI)
fader_c             = input.int(39, 'Fade', inline = 'f1', group = GRP_UI)

// ===========================================================================================================
//          Functions
// ===========================================================================================================

// @function Jurik Moving Average - TradingView: Moving Averages
Jurik(src, simple int len, jurik_phase, jurik_power) =>
    phaseRatio_l = jurik_phase < -100 ? 0.5 : jurik_phase > 100 ? 2.5 : jurik_phase / 100 + 1.5
    beta_l = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
    alpha_l = math.pow(beta_l, jurik_power)
    jma_l = 0.0
    e0_l = 0.0
    e0_l := (1 - alpha_l) * src + alpha_l * nz(e0_l[1])
    e1_l = 0.0
    e1_l := (src - e0_l) * (1 - beta_l) + beta_l * nz(e1_l[1])
    e2_l = 0.0
    e2_l := (e0_l + phaseRatio_l * e1_l - nz(jma_l[1])) * math.pow(1 - alpha_l, 2) + math.pow(alpha_l, 2) * nz(e2_l[1])
    jma_l := e2_l + nz(jma_l[1])

// @function T3 MA from Tilson3Average © KioseffTrading
t(src, x, a1_t3) =>
    y1 = ta.ema(src,x)
    y2 = ta.ema(y1, x)
    y3 = ta.ema(y2, x)
    y4 = ta.ema(y3, x)
    y5 = ta.ema(y4, x)
    y6 = ta.ema(y5, x)
    v = -a1_t3 * math.pow(a1_t3,2)
    v2 = 3 * math.pow(a1_t3,2) + 3 * math.pow(a1_t3,3)
    v3 = -6 * math.pow(a1_t3, 2) - 3 * a1_t3 - 3 * math.pow(a1_t3, 3)
    v4 = 1 + 3 * a1_t3 + a1_t3 * math.pow(a1_t3, 2) + 3 * math.pow(a1_t3, 2)
    v1 = v * y6 + v2 * y5 + v3 * y4 + v4 * y3
    v1

// Super Smoother Function 
ss(Series, Period) =>  // Super Smoother Function
    var PI = 2.0 * math.asin(1.0)
    var SQRT2 = math.sqrt(2.0)
    lambda = PI * SQRT2 / Period
    a1 = math.exp(-lambda)
    coeff2 = 2.0 * a1 * math.cos(lambda)
    coeff3 = -math.pow(a1, 2.0)
    coeff1 = 1.0 - coeff2 - coeff3
    filt1 = 0.0
    filt1 := coeff1 * (Series + nz(Series[1])) * 0.5 + coeff2 * nz(filt1[1]) + coeff3 * nz(filt1[2])
    filt1

// Hann Window Smoothing – Credits to @cheatcountry
doHannWindow(float _series, float _hannWindowLength) =>
    sum = 0.0, coef = 0.0
    for i = 1 to _hannWindowLength
        cosine = 1 - math.cos(2 * math.pi * i / (_hannWindowLength + 1))
        sum := sum + (cosine * nz(_series[i - 1]))
        coef := coef + cosine
    h = coef != 0 ? sum / coef : 0

// Choose MA type
MA_Calc(_data, _len, MAOption) =>
    value = 
          MAOption == SMA ? ta.sma(_data, _len) : 
          MAOption == EMA ? ta.ema(_data, _len) :
          MAOption == WMA ? ta.wma(_data, _len) : 
          MAOption == VWMA ? ta.vwma(_data, _len) : 
          MAOption == ALMA ? ta.alma(_data, _len, inputAlmaOffset_T, inputAlmaSigma_T) :
          MAOption == JURIK ? Jurik(_data, _len, phase_T, power_T) : 
          MAOption == T3 ? t(_data, _len, fac_t3_T) :
          MAOption == RSIMA ? ta.rma(_data, _len) :
          MAOption == MEDIAN ? ta.median(_data, _len) :
          MAOption == SS ? ss(_data, _len) :
          MAOption == HANN ? doHannWindow(_data, _len) :
      na

ipr_array(len, dnny, uppy) =>
    float[]   hiArray   =   array.new_float (0)
    float[]   loArray   =   array.new_float (0)
    float[]   cmArray   =   array.new_float (0)

    for i = 0 to len - 1
        array.push  (hiArray, high[i])
        array.push  (loArray, low[i])
        array.push  (cmArray, hlcc4[i])

    hlArray     =   array.concat (hiArray, loArray)
    hlcmArray   =   array.concat (hlArray, cmArray)
    
    q1          =   array.percentile_linear_interpolation (hlcmArray, dnny)
    q3          =   array.percentile_linear_interpolation (hlcmArray, uppy)

    iqr = (q3 - q1) / 2

// =================================================================================================
//                                  Calculations
// =================================================================================================

atrFactor   = atrActive ? atrMult * MA_Calc(ta.tr(true), period, atr_move)                             : 0
airFactor   = airActive ? airMult * MA_Calc(ipr_array(period, spacer, 100 - spacer), period, air_move) : 0

blender = nz(atrFactor) + nz(airFactor)

ipr_supertrend(source, len, multi) =>
    up = source - multi * blender
    up1 = nz(up[1], up)
    up := close[1] > up1 ? math.max(up, up1) : up
    dn = source + multi * blender
    dn1 = nz(dn[1], dn)
    dn := close[1] < dn1 ? math.min(dn, dn1) : dn
    trend = 1
    trend := nz(trend[1], trend)
    trend := trend == -1 and close > dn1 ? 1 : trend == 1 and close < up1 ? -1 : trend
    [up, dn, trend]

[upper, lower, supertrend] = ipr_supertrend(src, period, multiplier) 

// =================================================================================================
//                                  Plots
// =================================================================================================

upPlot          = plot(supertrend == 1 ? upper : na, title='Uptrend', style=plot.style_linebr, linewidth=2, color=color.new(up_, 100))
buySignal       = supertrend == 1 and supertrend[1] == -1
dnPlot          = plot(supertrend == 1 ? na : lower, title='Downtrend', style=plot.style_linebr, linewidth=2, color=color.new(dn_, 100))
sellSignal      = supertrend == -1 and supertrend[1] == 1

plotshape(buySignal ? upper : na, title='Uptrend Begins', location=location.absolute, style=shape.circle, size=size.small, color=color.new(up_, 0))
plotshape(sellSignal ? lower : na, title='Downtrend Begins', location=location.absolute, style=shape.circle, size=size.small, color=color.new(dn_, 0))

midPlot         = plot(ohlc4, title = '', style = plot.style_circles, display = display.none)
//fill(midPlot, upPlot, title = 'Uptrend Fill', color = bkgrnd ? color.new(up_, fader) : na)
//fill(midPlot, dnPlot, title = 'Downtrend Fill', color = bkgrnd ? color.new(dn_, fader) : na)

color_b         = supertrend == 1 ? up_ : dn_
barcolor(bar_it ? color.new(color_b, fader_c) : na)

// =================================================================================================
//                                  Alerts
// =================================================================================================

alertcondition(buySignal, title='.Supertrend Buy 🟢', message='Supertrend Buy 🟢')
alertcondition(sellSignal, title='.Supertrend Sell 🔴', message='Supertrend Sell 🔴')
changeCond      = supertrend != supertrend[1]
alertcondition(changeCond, title='Supertrend Direction Change 🟢/🔴', message='Supertrend has changed direction 🟢/🔴')


//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Settings//////////////////////ma hesaplama kısmı///////////////////////
//-----------------------------------------------------------------------------{
length22 = input(100)

incr   = input(10, "Increment")

fast   = input(10)

src22    = input(close)

//-----------------------------------------------------------------------------}
//Calculations
//-----------------------------------------------------------------------------{
var ma22    = 0.
var fma   = 0.
var alpha = 0.
var k     = 1 / incr

upper22 = ta.highest(length22)
lower22 = ta.lowest(length22)
init_ma = ta.sma(src22, length22)

cross = ta.cross(src22,ma22)

alpha := cross ? 2 / (length22 + 1)
  : src22 > ma22 and upper22 > upper22[1] ? alpha + k
  : src22 < ma22 and lower22 < lower22[1] ? alpha + k
  : alpha

ma22 := nz(ma22[1] + alpha[1] * (src22 - ma22[1]), init_ma)
  
fma := nz(cross ? math.avg(src22, fma[1])
  : src22 > ma22 ? math.max(src22, fma[1]) + (src22 - fma[1]) / fast
  : math.min(src22, fma[1]) + (src22 - fma[1]) / fast,src22)

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
css22 = fma > ma22 ? color.rgb(46, 245, 6) : color.red



plot122 = plot(ma22, "Stop", style=plot.style_circles, linewidth=2
  , color = css22)
///////////////////////////////////////dinamik range hesaplama kısmı/////////////////////

string reversal_type = input.string(defval='ATR', options=['ATR', 'Traditional'], title='Reversal Type:', inline='rt')
float reversal_modifier = input.float(defval=14, title='', inline='rt')
float reversal_multiplier = input.float(defval=3, title='', inline='rt', tooltip='-The type of range to use for the width of the channel. \n-Price modifier or atr length parameter depending on type. \n-Multiplier to apply to range.')
string ALT_TF = input.string(defval='D', title='Timeframe:', inline='itf')
bool USE_ALT_TF = input.bool(defval=true, title='Use Alternative Timeframe?', inline='itf')
float expansion_rate = input.float(defval=0.25, title='Expansion Rate:', inline='er')
bool expand_range = input.bool(defval=true, title='Expand Range', inline='er', tooltip='Expand Channel by rate when price touches extremes.')

float atr_1 = ta.atr(math.max(1, math.round(reversal_modifier)))
float reversal_block = 
 switch (reversal_type)
    ('ATR') => reversal_multiplier * atr_1 
    ('Traditional') => reversal_multiplier * reversal_modifier 
    => 0.0

bot_function() =>
    float _bot_base = high - reversal_block
    float _previous = nz(_bot_base[1], _bot_base)
    if _previous + reversal_block < high
        _bot_base := high - reversal_block
    else if low < _previous
        if expand_range
            _bot_base := low - reversal_block * expansion_rate 
        else
            _bot_base := low
    else
        _bot_base := _previous

top_function() =>
    float _top_base = low + reversal_block
    float _previous = nz(_top_base[1], _top_base)
    if _previous - reversal_block > low
        _top_base := low + reversal_block
    else if high > _previous
        if expand_range
            _top_base := high + reversal_block * expansion_rate 
        else
            _top_base := high
    else
        _top_base := _previous

bot_function_1 = bot_function()
security_1 = request.security(syminfo.tickerid, ALT_TF, bot_function_1)
bot_function_2 = bot_function()
bot = USE_ALT_TF ? security_1 : bot_function_2
top_function_1 = top_function()
security_2 = request.security(syminfo.tickerid, ALT_TF, top_function_1)
top_function_2 = top_function()
top = USE_ALT_TF ? security_2 : top_function_2

top_f = ta.change(bot) < 0 or ta.change(top) < 0 ? top : na
bot_f = ta.change(bot) < 0 or ta.change(top) < 0 ? bot : na
top_r = ta.change(bot) > 0 or ta.change(top) > 0 ? top : na
bot_r = ta.change(bot) > 0 or ta.change(top) > 0 ? bot : na

top_border = top - (top - bot) * 0.25
bot_border = bot + (top - bot) * 0.25
mid_border = bot + (top - bot) * 0.50

p_top_f = plot(series=top_f, title='0', color=color.new(color.lime, 0), style=plot.style_linebr)
//p_bot_f = plot(series=bot_f, title='tf', color=color.new(color.lime, 0), style=plot.style_linebr)
p_top_r = plot(series=top_r, title='1', color=color.new(color.red, 0), style=plot.style_linebr)
//p_bot_r = plot(series=bot_r, title='tr', color=color.new(color.red, 0), style=plot.style_linebr)
//fill(p_top_f, p_bot_f, color.new(color.lime, 90), title='direction fill')
//fill(p_top_r, p_bot_r, color.new(color.red, 90), title='direction fill')

plot(title='0', series=bot, color=color.new(color.lime, 0))
plot(title='1', series=top, color=color.new(color.red, 0))

plot(title='1', series=top_border, style=plot.style_circles, color=color.new(color.red, 0))
plot(title='0', series=bot_border, style=plot.style_circles, color=color.new(color.lime, 0))
plot(title='01', series=mid_border, style=plot.style_circles, color=color.new(#537cee, 0))
///////////////////////////////
//------------------------------------------------------------------------------
//Tooltips
//-----------------------------------------------------------------------------{
widthTooltip  = "Bin width percentage. Determine the length of the returned profile bin as a percentage of the Length setting"
offsetTooltip = "Determine the amount of bars each graphical elements are shifted by"

//-----------------------------------------------------------------------------}
//Settings
//-----------------------------------------------------------------------------{
length69 = input.int(200, minval = 2)
rows   = input.int(2, minval = 2)
useIb  = input(false, 'Use Intrabar', inline = 'intrabar') 
tf     = input.timeframe('1', ''    , inline = 'intrabar')

//Style
width69     = input.float(10, 'Width %', minval = 0, maxval = 100, group = 'Style', tooltip = widthTooltip)

showRange = input(false, 'Show Range Levels', inline = 'range', group = 'Style')
rangeCss  = input(color.gray, ''         , inline = 'range', group = 'Style')

bullBin   = input(#f321f3, 'Bullish Bin', inline = 'bull', group = 'Style')
bullMax   = input(true, 'Maximum'         , inline = 'bull', group = 'Style') 
bearBin   = input(#fbff00, 'Bearish Bin', inline = 'bear', group = 'Style')
bearMax   = input(true, 'Minimum'         , inline = 'bear', group = 'Style')

showFill = input(false, 'Show Fill'             , inline = 'fill', group = 'Style')
bullFill = input(color.new(#2157f3, 90), ''  , inline = 'fill', group = 'Style')
bearFill = input(color.new(#ff5d00, 90), ''  , inline = 'fill', group = 'Style')

offset = input.int(8, group = 'Style', tooltip = offsetTooltip)

//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
get_data() => [close, open]

//-----------------------------------------------------------------------------}
//Main variables
//-----------------------------------------------------------------------------{
var boxes69 = array.new<box>(0)

//Populate bins array
if barstate.isfirst
    for i = 0 to rows-1
        boxes69.push(box.new(na,na,na,na,na
          , text_valign = text.align_center
          , text_color = color.white))

n69 = bar_index
upper69 = ta.highest(length69)
lower69 = ta.lowest(length69)
sumad = math.sum(math.abs(close - open), length69)

//Get intrabar data
[get_close, get_open] = request.security_lower_tf(syminfo.tickerid, tf, get_data())

//-----------------------------------------------------------------------------}
//Set profile
//-----------------------------------------------------------------------------{
//Range levels
var ltop = line.new(na,na,na,na, color = rangeCss)
var l75  = line.new(na,na,na,na, color = rangeCss, style = line.style_dashed)
var l50  = line.new(na,na,na,na, color = rangeCss)
var l25  = line.new(na,na,na,na, color = rangeCss, style = line.style_dashed)
var lbtm = line.new(na,na,na,na, color = rangeCss)
var fill = linefill.new(ltop, lbtm, na)

//Max / Min levels
var bull_max = line.new(na,na,na,na, color = bullBin)
var bear_min = line.new(na,na,na,na, color = bearBin)

//Set profile
if barstate.islast
    avg = math.avg(upper69, lower69)
    avg75 = math.avg(upper69, avg)
    avg25 = math.avg(lower69, avg)

    //Set lines coordinates
    ltop.set_xy1(n69 - length69, upper69), ltop.set_xy2(n69 + offset, upper69)
    lbtm.set_xy1(n69 - length69, lower69), lbtm.set_xy2(n69 + offset, lower69)
    
    //Display range levels
    if showRange
        l75.set_xy1(n69 - length69, avg75) , l75.set_xy2(n69 + offset, avg75)
        l50.set_xy1(n69 - length69, avg)   , l50.set_xy2(n69 + offset, avg)
        l25.set_xy1(n69 - length69, avg25) , l25.set_xy2(n69 + offset, avg25)
    else
        ltop.set_color(na)
        lbtm.set_color(na)

    //Get bullish/absolute delta sums for each row
    up69 = upper69
    dn69 = upper69
    sums     = array.new_float(0)
    sums_abs = array.new_float(0)

    //Loop trough each rows
    for i = 0 to rows-1
        dn69 -= (upper69 - lower69) / rows
        sum = 0.
        den = 0.
        
        //Loop trough most recent bars
        for j = 0 to length69-1
            if useIb //Loop trough intrabar prices
                for k = 0 to (get_close[j]).size()-1
                    c = (get_close[j]).get(k)
                    o = (get_open[j]).get(k)
                    sum += math.max(c, o) <= up69 and math.min(c, o) >= dn69 ? c - o : 0
            else
                sum += high[j] > dn69 and low[j] < up69 ? close[j] - open[j] : 0
        
        sums.push(sum)
        sums_abs.push(math.abs(sum))

        up69 := dn69

    //Set profile bins
    max = sums_abs.max()
    up69 := upper69
    dn69 := upper69
    
    for [index, element] in sums
        dn69 -= (upper69 - lower69) / rows
        x2 = n69 + int(element / max * length69 * (width69 / 100))
        
        css = element > 0 ? color.new(bullBin, 50) : color.new(bearBin, 50)

        //Set box coordinates
        get_bx = boxes69.get(index)
        get_bx.set_lefttop(n69 + offset, .9 * up69 + .1 * dn69)
        get_bx.set_rightbottom(x2 + offset, .9 * dn69 + .1 * up69)
        get_bx.set_bgcolor(css)
        get_bx.set_text(str.tostring(element / sumad * 100, format.percent))
        
        //Set area MAX/MIN levels
        if element == sums.max() and bullMax
            bull_max_val = math.avg(up69, dn69)
            bull_max.set_xy1(n69 + offset, bull_max_val)
            bull_max.set_xy2(n69 - length69, bull_max_val)

        if element == sums.min() and bearMax
            bear_min_val = math.avg(up69, dn69)
            bear_min.set_xy1(x2 + offset, bear_min_val)
            bear_min.set_xy2(n69 - length69, bear_min_val)
            
        up69 := dn69
    
    //Fill Area
    if showFill
        fill.set_color(sums.sum() > 0 ? color.new(bullBin, 90) : color.new(bearBin, 90))

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


---

PHP Code:

---

 // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo

//@version=5
indicator("Predictive Ranges [LuxAlgo]", "*", overlay = true,max_boxes_count = 500, max_lines_count = 500, max_bars_back = 500)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length = input.int(200, 'Length', minval = 2)
mult55   = input.float(6., 'Factor', minval = 0, step = .5)
tf     = input.timeframe('', 'Timeframe')
src    = input(close, 'Source')

//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
pred_ranges(length, mult55)=>
    var avg = src
    var hold_atr = 0.

    atr = nz(ta.atr(length)) * mult55
        
    avg := src - avg > atr ? avg + atr : 
      avg - src > atr ? avg - atr : 
      avg
        
    hold_atr := avg != avg[1] ? atr / 2 : hold_atr
        
    [avg + hold_atr * 2, avg + hold_atr, avg, avg - hold_atr, avg - hold_atr * 2]

//-----------------------------------------------------------------------------}
//Calculation
//-----------------------------------------------------------------------------{
[prR2
  , prR1
  , avg
  , prS1
  , prS2] = request.security(syminfo.tickerid, tf, pred_ranges(length, mult55))

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot_pru2  = plot(prR2, 'Direnç2', avg != avg[1] ? na : #f2364600)
plot_pru1  = plot(prR1, 'Direnç1', avg != avg[1] ? na : #f2364600)
plot_pravg = plot(avg , 'Ortalama', avg != avg[1] ? na : #f1ce0b)
plot_prl1  = plot(prS1, 'Destek1', avg != avg[1] ? na : #08998100)
plot_prl2  = plot(prS2, 'Destek2', avg != avg[1] ? na : #08998100)

//Fills
fill(plot_pru2, plot_pru1, avg != avg[1] ? na : color.new(#f23645, 65))
fill(plot_prl1, plot_prl2, avg != avg[1] ? na : color.new(#089981, 65))

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

//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length11 = input(20)

src11 = input(close)

//------------------------------------------------------------------------------
//Signal moving average
//-----------------------------------------------------------------------------{
var ma = 0.
var os = 0.

target = ta.sma(src11, length11)
abs_diff = math.abs(target - target[1])

r2 = math.pow(ta.correlation(close, bar_index, length11), 2)

os := r2 > 0.5 ? math.sign(src11[1] - target[1]) : os

ma := r2 > 0.5 ? r2 * target + (1 - r2) * nz(ma[1], target)
  : ma[1] - abs_diff * os
  
  
//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot0 = plot(src11, display = display.none, editable = false)

css = os == 1 ? #0cb51a : #ff1100
plot1 = plot(ma, 'MA0'
  , css)
  
fill_css = src > ma ? color.new(#0cb51a, 80) : color.new(#ff1100, 80)
//fill(plot0, plot1, fill_css, 'Fill')

//-----------------------------------------------------------------------------}
//Settings
//-----------------------------------------------------------------------------{
length22 = input(100)

incr   = input(10, "Increment")

fast   = input(10)

src22    = input(close)

//-----------------------------------------------------------------------------}
//Calculations
//-----------------------------------------------------------------------------{
var ma22    = 0.
var fma   = 0.
var alpha = 0.
var k     = 1 / incr

upper = ta.highest(length22)
lower = ta.lowest(length22)
init_ma = ta.sma(src22, length22)

cross = ta.cross(src22,ma22)

alpha := cross ? 2 / (length + 1)
  : src22 > ma22 and upper > upper[1] ? alpha + k
  : src22 < ma22 and lower < lower[1] ? alpha + k
  : alpha

ma22 := nz(ma22[1] + alpha[1] * (src22 - ma22[1]), init_ma)
  
fma := nz(cross ? math.avg(src22, fma[1])
  : src22 > ma22 ? math.max(src22, fma[1]) + (src22 - fma[1]) / fast
  : math.min(src22, fma[1]) + (src22 - fma[1]) / fast,src22)

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
css22 = fma > ma22 ? color.rgb(46, 245, 6) : color.red



plot122 = plot(ma22, "MA1"
  , color = css22)

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


---