Tradingview

[@yörük@]

// © Kinetik Komuta Merkezi [Nihai KKM V10 - Kuvvetler Ayrýlýðý]
//@version=6
indicator("Nihai KKM Sniper", shorttitle="KKM V10", overlay=true, max_labels_count=50, max_lines_count=50)

// ─────────────────────────────────────────────────────────────────
// 7. SAR HESAPLAMALARI VE ÇÝZÝMLER


float sarMavi = ta.sar(0.0, 0.003, 0.02), sarSari = ta.sar(0.0, 0.001, 0.02), sarFusya = ta.sar(0.001, 0.0005, 0.02)
plot(sarMavi, "X", color.new(#040cfb, 0), 1, plot.style_cross)
plot(sarSari, "Y", color.new(#040cfb, 0), 1, plot.style_cross)
plot(sarFusya, "Z", color.new(#040cfb, 0), 1, plot.style_cross)
// 0. MERKEZÝ FONKSÝYONLAR (Sýfýr Gecikme Motoru)
// ─────────────────────────────────────────────────────────────────
f_zlema(series float src, simple int len) =>
    float ema1 = ta.ema(src, len)
    float ema2 = ta.ema(ema1, len)
    ema1 + (ema1 - ema2)

// ─────────────────────────────────────────────────────────────────
// 1. GÝRDÝLER
// ─────────────────────────────────────────────────────────────────
group_l1 = "1. Kinetik Motor (Yörük)"
int atrLen = input.int(20, "L1 Hafýza (ATR)", group=group_l1)
float atrMult = input.float(3.5, "L1 Gürültü Duvarý", step=0.1, group=group_l1)
float mu = input.float(0.6, "L1 Yakýnsaklýk (μ)", step=0.1, group=group_l1)

group_vx = "2. Z-Vortex Barlar"
int vLen = input.int(30, "Vortex Periyodu", group=group_vx)
int zLen = input.int(5,  "ZLEMA (Sýfýr Gecikme)", group=group_vx)
float vHot = input.float(1.1, "Patlama Eþiði", step=0.05, group=group_vx)

group_holy = "3. Kurumsal S-TWAP Filtresi"
float maxTension = input.float(2.0, "Maksimum Gerginlik Sýnýrý", step=0.1, group=group_holy)

// ─────────────────────────────────────────────────────────────────
// 2. ARKA PLAN HESAPLAMALARI (SAF YÖRÜK VE TWAP)
// ─────────────────────────────────────────────────────────────────
f_yoruk_pure() =>
    float threshold = ta.atr(atrLen) * atrMult
    var float z = na
    var float v = 0.0
    if bar_index == 0
        z := hl2
    else
        float zPrev = z[1], float vPrev = v[1]
        float zPred = zPrev + vPrev
        float zTemp = zPred + mu * (hl2 - zPred)
        float diff = zTemp - zPrev
        if math.abs(diff) > threshold
            v := math.sign(diff) * (math.abs(diff) - threshold)
        else
            v := 0.0
        z := zPrev + v
    z

// TWAP Katmanlarý
f_get_twap(string tf) =>
    bool isNew = ta.change(time(tf)) != 0
    var float sP = 0.0, var float bC = 0.0
    if isNew or bar_index == 0
        sP := hl2, bC := 1.0
    else
        sP += hl2, bC += 1.0
    sP / bC

float curTwapH = f_get_twap("60")
float curTwapD = f_get_twap("D")

// ─────────────────────────────────────────────────────────────────
// 3. Z-VORTEX (KÝNETÝK IVME)
// ─────────────────────────────────────────────────────────────────
float vPlusBase = math.sum(math.abs(high - low[1]), vLen)
float vNegBase  = math.sum(math.abs(low - high[1]), vLen)
float tRange    = math.sum(ta.atr(1), vLen)

float plusZ = f_zlema(tRange > 0 ? vPlusBase / tRange : 0, zLen)
float negZ  = f_zlema(tRange > 0 ? vNegBase / tRange : 0, zLen)

color vxColor = plusZ > vHot ? #00e676 : negZ > vHot ? #ff1744 : #787b86
barcolor(vxColor, title="Z-Vortex Barlar")

// ─────────────────────────────────────────────────────────────────
// 4. ÞELALE ÇÝZÝMLERÝ (Yörük MTF)
// ─────────────────────────────────────────────────────────────────
float y1   = f_yoruk_pure() 
float y3   = request.security(syminfo.tickerid, "3",   f_yoruk_pure(), lookahead=barmerge.lookahead_off)
float y5   = request.security(syminfo.tickerid, "5",   f_yoruk_pure(), lookahead=barmerge.lookahead_off)
float y15  = request.security(syminfo.tickerid, "15",  f_yoruk_pure(), lookahead=barmerge.lookahead_off)
float y60  = request.security(syminfo.tickerid, "60",  f_yoruk_pure(), lookahead=barmerge.lookahead_off)
float y240 = request.security(syminfo.tickerid, "240", f_yoruk_pure(), lookahead=barmerge.lookahead_off) 
float yD   = request.security(syminfo.tickerid, "D",   f_yoruk_pure(), lookahead=barmerge.lookahead_off) 

plot(y1,   "1m",  color=color.new(#ffeb3b, 0), linewidth=1, style=plot.style_stepline)
//plot(y3,   "3m",  color=color.new(#ff9800, 00), linewidth=1, style=plot.style_stepline, display = display.pane)
//plot(y5,   "5m",  color=color.new(#e91e63, 100), linewidth=1, style=plot.style_stepline, display = display.pane)
//plot(y15,  "15m", color=color.new(#9c27b0, 100), linewidth=2, style=plot.style_stepline, display = display.pane)

// ─────────────────────────────────────────────────────────────────
// 5. TERMINAL PUSULASI (HUD)
// ─────────────────────────────────────────────────────────────────
var table terminal = table.new(position.bottom_right, 2, 11, bgcolor=color.new(color.black, 60), border_color=color.new(color.gray, 80), border_width=1)
f_col(val) => close > val ? #00e676 : close < val ? #ff1744 : color.silver

if barstate.islast
    table.cell(terminal, 0, 0, "AÝ GEMÝNÝ PRO 2026", text_color=color.yellow, bgcolor=color.new(color.black, 40))
    table.merge_cells(terminal, 0, 0, 1, 0)
    
    table.cell(terminal, 0, 2, "STOP (Y1/Y3 AVG)", text_color=color.white)
    table.cell(terminal, 1, 2, str.tostring(math.round((y1+y3)/2, 2)), text_color=color.orange)

    table.cell(terminal, 0, 3, "1m", text_color=color.white)
    table.cell(terminal, 1, 3, str.tostring(math.round(y1, 2)), text_color=f_col(y1))
    table.cell(terminal, 0, 4, "3m", text_color=color.white)
    table.cell(terminal, 1, 4, str.tostring(math.round(y3, 2)), text_color=f_col(y3))
    table.cell(terminal, 0, 5, "5m", text_color=color.white)
    table.cell(terminal, 1, 5, str.tostring(math.round(y5, 2)), text_color=f_col(y5))
    table.cell(terminal, 0, 6, "15m", text_color=color.white)
    table.cell(terminal, 1, 6, str.tostring(math.round(y15, 2)), text_color=f_col(y15))
    table.cell(terminal, 0, 7, "60m", text_color=color.white)
    table.cell(terminal, 1, 7, str.tostring(math.round(y60, 2)), text_color=f_col(y60))
    table.cell(terminal, 0, 8, "4S", text_color=color.white)
    table.cell(terminal, 1, 8, str.tostring(math.round(y240, 2)), text_color=f_col(y240))
    table.cell(terminal, 0, 9, "1G", text_color=color.white)
    table.cell(terminal, 1, 9, str.tostring(math.round(yD, 2)), text_color=f_col(yD))
    table.cell(terminal, 0, 10, "@yörük@ Yatýrým Tavsiyesi DEÐÝLDÝR.", text_color=color.white)
    table.merge_cells(terminal, 0, 10, 1, 10)

// ─────────────────────────────────────────────────────────────────

// ─────────────────────────────────────────────────────────────────
// 7. PURE TWAP-DVDI (Kinetik Akýþ)
// ─────────────────────────────────────────────────────────────────
f_ema(float x, int t) =>
    var float _ema = na
    _ema := na(_ema[1]) ? x : (x - _ema[1]) * (2 / (t + 1)) + _ema[1]

f_twap_dvdi(float x, int t1, int t2) =>
    var float pvi = 0.0, var float nvi = 0.0
    pvi := x > nz(x[1]) ? pvi + (x - nz(x[1])) : pvi
    nvi := x < nz(x[1]) ? nvi - (x - nz(x[1])) : nvi
    [f_ema(pvi - f_ema(pvi, t1), t2), f_ema(nvi - f_ema(nvi, t1), t2)]

[pdiv, ndiv] = f_twap_dvdi(hl2, 200, 50)
color zemin = (pdiv > ndiv) ? (pdiv > 0 ? #05ffa6 : #05ffa6) : (ndiv > 0 ? #ff0a70 : #ff0a70)
bgcolor(color.new(zemin, 85), title="Kinetik Akýþ Zemini")
///////////

// ─────────────────────────────────────────────────────────────────
// 1. DÝNAMÝK YOÐUNLUK MOTORU (Zamaný Deðil, Maddeyi Ölçer)
// ─────────────────────────────────────────────────────────────────
// Bu motor ayný 1m verisini alýr ama ona farklý kutle dirençleri uygular.
f_kutu_kutle(int _atrLen, float _atrMult, float _mu) =>
    float threshold = ta.atr(_atrLen) * _atrMult
    var float z = na
    var float v = 0.0
    if bar_index == 0
        z := hl2
    else
        float zPrev = z[1], float vPrev = v[1]
        float zPred = zPrev + vPrev
        float zTemp = zPred + _mu * (hl2 - zPred)
        float diff = zTemp - zPrev
        if math.abs(diff) > threshold
            v := math.sign(diff) * (math.abs(diff) - threshold)
        else
            v := 0.0
        z := zPrev + v
    z

// ─────────────────────────────────────────────────────────────────
// 2. KÜTLE MATRÝSÝ (Camdan Çeliðe Kurumsal Maliyetler)
// ─────────────────────────────────────────────────────────────────
// Ayný 1 dakikalýk grafikte, merminin (fiyatýn) deleceði katmanlar:
float cam   = f_kutu_kutle(1, 1.0, 0.05)   // CAM: Çok kýrýlgan, mermi anýnda deler.
float tahta = f_kutu_kutle(1, 1.5, 0.5)   // TAHTA: Standart perakende direnci.
float beton = f_kutu_kutle(1, 1.0, 0.1)   // BETON: Orta ölçekli balina maliyeti.
float demir = f_kutu_kutle(1, 0.01, 0.1)   // DEMÝR: Kurumsal fonlarýn aðýr duvarý.
float celik = f_kutu_kutle(1,  0.01, 0.01)  // ÇELÝK: Komutanýn Tank Zýrhý! (Delinmesi en zor)

// ─────────────────────────────────────────────────────────────────
// 3. YOÐUNLUK ÇÝZÝMLERÝ (Ekraný Kirletmeden)
// ─────────────────────────────────────────────────────────────────
plot(celik, "Çelik", color=color.new(#d500f9, 0), linewidth=1, style=plot.style_stepline) // Mor
//plot(demir, "Demir", color=color.new(#ff9100, 0), linewidth=2, style=plot.style_stepline) // Turuncu
//plot(beton, "Beton", color=color.new(#2979ff, 00), linewidth=1, style=plot.style_stepline, display = display.pane) // Mavi
plot(tahta, "Tahta", color=color.new(#ffeb3b, 00), linewidth=1, style=plot.style_stepline, display = display.pane) // Yeþil
plot(cam,   "Cam",   color=color.new(#ffeb3b, 0), linewidth=1, style=plot.style_stepline) // Beyaz

// ─────────────────────────────────────────────────────────────────
// 4. SAR FÜZYONU VE AYNASI (Öncü Kalkan)
// ─────────────────────────────────────────────────────────────────
float af_start = 0.1
float af_step  = 0.1
float af_max   = 0.1

var bool is_long = true
var float ep = hl2
var float sar_f = na
var float af = af_start

if na(sar_f)
    sar_f := close - ta.atr(14)

float prev_sar = sar_f
float prev_ep = ep

if is_long
    sar_f := prev_sar + af * (prev_ep - prev_sar)
    if hl2 > ep
        ep := hl2
        af := math.min(af + af_step, af_max)
    if hl2 < sar_f
        is_long := false
        sar_f := ep
        ep := hl2
        af := af_start
else
    sar_f := prev_sar + af * (prev_ep - prev_sar)
    if hl2 < ep
        ep := hl2
        af := math.min(af + af_step, af_max)
    if hl2 > sar_f
        is_long := true
        sar_f := ep
        ep := hl2
        af := af_start

// 🚀 AYNA SAR (Hedef ve Gerginlik Ölçer)
float sar_ayna = (2 * hl2) - sar_f

// Sinyaller
bool fuzyon_al = is_long and not is_long[1]
bool fuzyon_sat = not is_long and is_long[1]

// Görseller
color sar_renk = is_long ? color.new(color.yellow, 0) : color.new(#ff1744, 0)
//plot(sar_f, "SAR Füzyonu", color=sar_renk, style=plot.style_circles, linewidth=1)

color ayna_renk = is_long ? color.new(color.white, 0) : color.new(color.red, 0)
plot(sar_ayna, "Ayna SAR", color=ayna_renk, style=plot.style_line, linewidth=1)

//plotshape(fuzyon_sat, title="Sat", style=shape.diamond, location=location.abovebar, color=#ff1744, size=size.small)
//plotshape(fuzyon_al, title="Al", style=shape.diamond, location=location.belowbar, color=#00e676, size=size.small)
////
// ASYMMETRIC TREND ENGINE (GÖRÜNMEZ HESAPLAYICI)
// ─────────────────────────────────────────────────────────────────
float asy_src        = hl2
int   asy_lookback   = 50
float asy_mult       = 5.5

float asy_vol_threshold = ta.stdev(asy_src, asy_lookback) * asy_mult

var float asy_trend_line = na
var int   asy_trend_dir  = 0
var int   asy_prev_dir   = 0

if na(asy_trend_line)
    asy_trend_line := asy_src
else
    asy_prev_dir := asy_trend_dir
    if asy_trend_dir >= 0
        if asy_src > asy_trend_line + asy_vol_threshold * 0.5
            asy_trend_line := math.max(asy_trend_line, asy_src - asy_vol_threshold * 0.25)
            asy_trend_dir  := 1
        else if asy_src < asy_trend_line - asy_vol_threshold
            asy_trend_line := asy_src + asy_vol_threshold * 0.25
            asy_trend_dir  := -1
    else
        if asy_src < asy_trend_line - asy_vol_threshold * 0.5
            asy_trend_line := math.min(asy_trend_line, asy_src + asy_vol_threshold * 0.25)
            asy_trend_dir  := -1
        else if asy_src > asy_trend_line + asy_vol_threshold
            asy_trend_line := asy_src - asy_vol_threshold * 0.25
            asy_trend_dir  := 1

bool turned_bullish = asy_trend_dir == 1  and asy_trend_dir[1] == -1
bool turned_bearish = asy_trend_dir == -1 and asy_trend_dir[1] == 1
bool is_reversal    = asy_trend_dir != asy_prev_dir and bar_index > 0

float yoruk_1m = ta.sma(hl2, 21)
//plot(yoruk_1m, "0", color=color.new(color.aqua, 20), linewidth=2)

color rev_color = asy_trend_dir == 1 ? #00ffaa : #ff0000
plotchar(is_reversal ? (asy_trend_dir == 1 ? low : high) : na, "KKM Reversal", "⦿", location = location.absolute, color = rev_color, size = size.small)

//plotshape(turned_bullish, style=shape.diamond, location=location.belowbar, color=#00ffaa, size=size.tiny, title="L Entry")
//plotshape(turned_bearish, style=shape.diamond, location=location.abovebar, color=#ff0000, size=size.tiny, title="S Entry")

alertcondition(turned_bullish, "KKM Bullish Reversal", "Kütle Ývmesi YUKARI döndü!")
alertcondition(turned_bearish, "KKM Bearish Reversal", "Kütle Ývmesi AÞAÐI döndü!") 

[@yörük@]

// © Kinetik Komuta Merkezi [Nihai KKM V10 - Kuvvetler Ayrýlýðý]
//@version=6
indicator("Nihai KKM Sniper", shorttitle="KKM V10", overlay=true, max_labels_count=50, max_lines_count=50)


// 0. MERKEZÝ FONKSÝYONLAR (Sýfýr Gecikme Motoru)
// ─────────────────────────────────────────────────────────────────
f_zlema(series float src, simple int len) =>
    float ema1 = ta.ema(src, len)
    float ema2 = ta.ema(ema1, len)
    ema1 + (ema1 - ema2)

// ─────────────────────────────────────────────────────────────────
// 1. GÝRDÝLER
// ─────────────────────────────────────────────────────────────────
group_l1 = "1. Kinetik Motor (Yörük)"
int atrLen = input.int(20, "L1 Hafýza (ATR)", group=group_l1)
float atrMult = input.float(3.5, "L1 Gürültü Duvarý", step=0.1, group=group_l1)
float mu = input.float(0.6, "L1 Yakýnsaklýk (μ)", step=0.1, group=group_l1)

group_vx = "2. Z-Vortex Barlar"
int vLen = input.int(30, "Vortex Periyodu", group=group_vx)
int zLen = input.int(5,  "ZLEMA (Sýfýr Gecikme)", group=group_vx)
float vHot = input.float(1.1, "Patlama Eþiði", step=0.05, group=group_vx)

group_holy = "3. Kurumsal S-TWAP Filtresi"
float maxTension = input.float(2.0, "Maksimum Gerginlik Sýnýrý", step=0.1, group=group_holy)


// ─────────────────────────────────────────────────────────────────
// 1. DÝNAMÝK YOÐUNLUK MOTORU (Zamaný Deðil, Maddeyi Ölçer)
// ─────────────────────────────────────────────────────────────────
// Bu motor ayný 1m verisini alýr ama ona farklý kutle dirençleri uygular.
f_kutu_kutle(int _atrLen, float _atrMult, float _mu) =>
    float threshold = ta.atr(_atrLen) * _atrMult
    var float z = na
    var float v = 0.0
    if bar_index == 0
        z := hl2
    else
        float zPrev = z[1], float vPrev = v[1]
        float zPred = zPrev + vPrev
        float zTemp = zPred + _mu * (hl2 - zPred)
        float diff = zTemp - zPrev
        if math.abs(diff) > threshold
            v := math.sign(diff) * (math.abs(diff) - threshold)
        else
            v := 0.0
        z := zPrev + v
    z

// ─────────────────────────────────────────────────────────────────
// 2. KÜTLE MATRÝSÝ (Camdan Çeliðe Kurumsal Maliyetler)
// ─────────────────────────────────────────────────────────────────
// Ayný 1 dakikalýk grafikte, merminin (fiyatýn) deleceði katmanlar:
float cam   = f_kutu_kutle(1, 1.0, 0.05)   // CAM: Çok kýrýlgan, mermi anýnda deler.

float celik = f_kutu_kutle(1,  0.01, 0.01)  // ÇELÝK: Komutanýn Tank Zýrhý! (Delinmesi en zor)

// ─────────────────────────────────────────────────────────────────
// 3. YOÐUNLUK ÇÝZÝMLERÝ (Ekraný Kirletmeden)
// ─────────────────────────────────────────────────────────────────
plot(celik, "Çelik", color=color.new(#d500f9, 0), linewidth=1, style=plot.style_stepline) // Mor

plot(cam,   "Cam",   color=color.new(#ffeb3b, 0), linewidth=1, style=plot.style_stepline) // Beyaz

// ───────────────────────────────────────────────────────────────── 

[@yörük@]

//@version=6
indicator(".", overlay=true)

color col_mid = color.white
color col_up  = color.new(#00e676, 0)
color col_dn  = color.new(#ff1744, 0)

float mid200 = ta.hma(ta.median(hl2, 89 * 2), 233)

plot(mid200, title = "Yörük", color = col_mid, linewidth = 1)

color bar_col = close > mid200 ? col_up : close < mid200 ? col_dn : color.gray

// Mumlarýn renklerini uygula
barcolor(bar_col) 

[@yörük@]

//@version=6
indicator("Fibonacci Kinetik Röntgen", shorttitle="FIB-X", overlay=true)

color col_mid = color.white
color col_up  = color.new(#00e676, 0)
color col_dn  = color.new(#ff1744, 0)
color col_nt  = color.new(#787b86, 50) // Gri (Nötr Bölge)

// ─────────────────────────────────────────────────────────────────
// 1. ANA OMURGA (YÖRÜK ÇÝZGÝSÝ)
// ─────────────────────────────────────────────────────────────────
float mid200 = ta.hma(ta.median(hl2, 1 * 2), 377)
plot(mid200, title="Yörük (Ana Kalkan)", color=col_mid, linewidth=2)

// ─────────────────────────────────────────────────────────────────
// 2. FIBONACCI KUANTUM ÇÝFTLERÝ (13-21, 13-55, 89-144, 89-233)
// ─────────────────────────────────────────────────────────────────
// Taktik Katmanlar (Mikro)
float fib_13_21 = ta.hma(ta.median(hl2, 13), 21)
float fib_13_55 = ta.hma(ta.median(hl2, 13), 55)

// Stratejik Katmanlar (Makro)
float fib_89_144 = ta.hma(ta.median(hl2, 89), 144)
float fib_89_233 = ta.hma(ta.median(hl2, 89), 233)

// ─────────────────────────────────────────────────────────────────
// 3. TAM MUTABAKAT RENKLENDÝRMESÝ (ATEÞLEME KONTROLÜ)
// ─────────────────────────────────────────────────────────────────
// Fiyat tüm katmanlarýn (Mikro + Makro) üzerindeyse Kusursuz Boða
bool is_bull = close > fib_13_21 and close > fib_13_55 and close > fib_89_144 and close > fib_89_233

// Fiyat tüm katmanlarýn altýndaysa Kusursuz Ayý
bool is_bear = close < fib_13_21 and close < fib_13_55 and close < fib_89_144 and close < fib_89_233

// Renk Atamasý
color bar_col = is_bull ? col_up : is_bear ? col_dn : col_nt

// Mumlarýn Renklerini Uygula
barcolor(bar_col, title="Kinetik Bar Rengi") 

[@yörük@]

// © Kinetik Komuta Merkezi [Saf L1 Baseline]
//@version=6
indicator(":]", overlay = true)

// ─────────────────────────────────────────────────────────────────
// 0. GÝRDÝLER VE AYARLAR
// ─────────────────────────────────────────────────────────────────
group_l1 = "L1 Kinetik Filtre (Ana baseline)"
int atrLen = input.int(20, "L1 Hafýza (ATR)", group=group_l1)
float atrMult = input.float(3.5, "L1 Gürültü Duvarý", step=0.1, group=group_l1)
float mu = input.float(0.6, "L1 Yakýnsaklýk (μ)", step=0.1, group=group_l1)

// ─────────────────────────────────────────────────────────────────
// 1. MOTOR: L1 KÝNETÝK FÝLTRE (ANA BASELINE)
// ─────────────────────────────────────────────────────────────────
float threshold = ta.atr(atrLen) * atrMult
var float z = na
var float v = 0.0

if bar_index == 0
    z := close
else
    float zPrev = z[1], float vPrev = v[1]
    float zPred = zPrev + vPrev
    float zTemp = zPred + mu * (close - zPred)
    float diff = zTemp - zPrev
    
    if math.abs(diff) > threshold
        v := math.sign(diff) * (math.abs(diff) - threshold)
    else
        v := 0.0
        
    z := zPrev + v

// @yörük@ Çizgisi
plot(z, "@yörük@", color=color.new(color.fuchsia, 0), linewidth=2, style=plot.style_stepline) 

[@yörük@]

// © Kinetik Komuta Merkezi [Momentum Makasý - Düzeltilmiþ Sentez]
//@version=6
indicator("Kinetik Komuta Merkezi [Temiz Sentez]", overlay = true, max_lines_count = 500)

// ─────────────────────────────────────────────────────────────────
// GÝRDÝLER VE RENKLER
// ─────────────────────────────────────────────────────────────────
int len = input.int(50, "Maliyet & Atalet Uzunluðu")

group_kin = "Kinetik Hedefler & Renkler"
col_up1 = input.color(#00e676, "Boða Ana", group=group_kin)
col_dn1 = input.color(#ff1744, "Ayý Ana", group=group_kin)

color col_mid   = color.white
color col_htf   = color.yellow
color col_cloud_up = color.new(#00e676, 85)
color col_cloud_dn = color.new(#ff1744, 85)

// ─────────────────────────────────────────────────────────────────
// 1. MOTOR: KÝNETÝK BULUT (ZEMÝN VE TREND)
// ─────────────────────────────────────────────────────────────────
// ZEMÝN / ATALET (Beyaz Trambolin): 100 barlýk medyan. Çok aðýr ve sarsýlmazdýr.
float mid = ta.hma(ta.median(hl2, len * 2), 10)
// HIZ / TREND (Sarý Çizgi): 50 barlýk EMA. Fiyata çok daha atik tepki verir.
float htf_ema = ta.ema(close, len)

// Momentum Yönü: Atik olan (Sarý), Aðýr olanýn (Beyaz) üstündeyse BOÐA'dýr.
bool is_bull_trend = htf_ema > mid
bool is_bear_trend = htf_ema < mid

// Çizimleri Tanýmla
p1 = plot(mid, color=col_mid, linewidth=1, title="Zemin (Beyaz)")
p2 = plot(htf_ema, color=col_htf, linewidth=1, title="Trend (Sarý)")

// Bulutu Doldur
fill(p1, p2, is_bull_trend ? col_cloud_up : col_cloud_dn, title="Kinetik Bulut")

// ─────────────────────────────────────────────────────────────────
// MUM BOYAMA (SIFIR ÇATIÞMA)
// ─────────────────────────────────────────────────────────────────
barcolor(is_bull_trend ? col_up1 : col_dn1)

// ─────────────────────────────────────────────────────────────────
// 2. MOTOR: 3'LÜ SAR VE KÝNETÝK AYNALAMA
// ─────────────────────────────────────────────────────────────────
float sar1 = ta.sar(0.02, 0.02, 0.2)
float sar2 = ta.sar(0.01, 0.01, 0.1)
float sar3 = ta.sar(0.005, 0.005, 0.05)

float dist1 = math.abs(close - sar1)
float dist2 = math.abs(close - sar2)
float dist3 = math.abs(close - sar3)

float t_up1 = ta.hma(close + dist1, 10)
float t_up2 = ta.hma(close + dist2, 10)
float t_up3 = ta.hma(close + dist3, 10)

float t_dn1 = ta.hma(close - dist1, 10)
float t_dn2 = ta.hma(close - dist2, 10)
float t_dn3 = ta.hma(close - dist3, 10)

// ─────────────────────────────────────────────────────────────────
// 3. MOTOR: HAM VURUÞ TESPÝTÝ (Trend Filtresi Bulutta)
// ─────────────────────────────────────────────────────────────────
bool hit_u3 = ta.crossover(high, t_up3) and is_bull_trend
bool hit_u2 = ta.crossover(high, t_up2) and is_bull_trend and not hit_u3
bool hit_u1 = ta.crossover(high, t_up1) and is_bull_trend and not hit_u2 and not hit_u3

bool hit_d3 = ta.crossunder(low, t_dn3) and is_bear_trend
bool hit_d2 = ta.crossunder(low, t_dn2) and is_bear_trend and not hit_d3
bool hit_d1 = ta.crossunder(low, t_dn1) and is_bear_trend and not hit_d2 and not hit_d3

// ─────────────────────────────────────────────────────────────────
// GÖRSEL MOTOR (Lazer Noktalar ve Temiz Rakamlar)
// ─────────────────────────────────────────────────────────────────
plot(hit_u1 ? t_up1 : na, style=plot.style_circles, linewidth=2, color=col_up1)
plot(hit_u2 ? t_up2 : na, style=plot.style_circles, linewidth=3, color=col_up1)
plot(hit_u3 ? t_up3 : na, style=plot.style_circles, linewidth=4, color=col_up1)

plot(hit_d1 ? t_dn1 : na, style=plot.style_circles, linewidth=2, color=col_dn1)
plot(hit_d2 ? t_dn2 : na, style=plot.style_circles, linewidth=3, color=col_dn1)
plot(hit_d3 ? t_dn3 : na, style=plot.style_circles, linewidth=4, color=col_dn1)

plotchar(hit_u1, char="1", location=location.abovebar, color=col_up1, size=size.tiny)
plotchar(hit_u2, char="2", location=location.abovebar, color=col_up1, size=size.tiny)
plotchar(hit_u3, char="3", location=location.abovebar, color=col_up1, size=size.tiny)

plotchar(hit_d1, char="1", location=location.belowbar, color=col_dn1, size=size.tiny)
plotchar(hit_d2, char="2", location=location.belowbar, color=col_dn1, size=size.tiny)
plotchar(hit_d3, char="3", location=location.belowbar, color=col_dn1, size=size.tiny)

// ─────────────────────────────────────────────────────────────────
// SON MÜHÜR ÇÝZGÝLERÝ (Enerji Duvarlarý)
// ─────────────────────────────────────────────────────────────────
var line bull_seal = na
var line bear_seal = na

if hit_u3
    if not na(bull_seal)
        line.delete(bull_seal)
    bull_seal := line.new(bar_index, high, bar_index + 1, high, color=col_up1, width=2, style=line.style_dashed, extend=extend.right)

if hit_d3
    if not na(bear_seal)
        line.delete(bear_seal)
    bear_seal := line.new(bar_index, low, bar_index + 1, low, color=col_dn1, width=2, style=line.style_dashed, extend=extend.right)

///////////////
// (AÝ) Ýmza
var table ytd_table = table.new(position.bottom_center, 1, 1)
if barstate.islast
    table.cell(ytd_table, 0, 0, "(AÝ) Eðitim çalýþmasýdýr. Yatýrým tavsiyesi KULLANILAMAZ.", text_color=color.new(color.white, 0), text_size=size.normal) 

[@yörük@]

// © Kinetik Komuta Merkezi [Masterpiece V6.9 - Z-RS Göreceli Güç]
//@version=6
indicator("KKM V6.9 Z-RS (Kinetik Göreceli Güç)", shorttitle="KKM Z-RS", overlay=false)

// ─────────────────────────────────────────────────────────────────
// 1. GÝRDÝLER VE ÝSTÝHBARAT
// ─────────────────────────────────────────────────────────────────
string symB = input.symbol("BIST:XU100", "Kýyaslanacak Endeks / Hisse")
int zLen = input.int(233, "ZLEMA (Sýfýr Gecikme) Periyodu", minval=1)

// Endeksin verilerini sýfýr gecikme ve repaint olmadan (lookahead_off) çek
[o2, h2, l2, c2, hl2_2] = request.security(symB, timeframe.period, [open, high, low, close, hl2], lookahead=barmerge.lookahead_off)

// ─────────────────────────────────────────────────────────────────
// 2. KÝNETÝK ORAN (RELATIVE STRENGTH) MATEMATÝÐÝ
// ─────────────────────────────────────────────────────────────────
// Hisse fiyatýný, Endeks fiyatýna bölerek "Göreceli Güç Mumlarý" yaratýyoruz.
float rs_o = open / o2
float rs_h = high / h2
float rs_l = low / l2
float rs_c = close / c2

// Kütle merkezlerinin oraný (Ana Kuantum Çekirdeði)
float rs_hl2 = hl2 / hl2_2

// ─────────────────────────────────────────────────────────────────
// 3. ZLEMA MOTORU (SIFIR GECÝKMELÝ ÝVME)
// ─────────────────────────────────────────────────────────────────
f_zlema(series float src, simple int len) =>
    float ema1 = ta.ema(src, len)
    float ema2 = ta.ema(ema1, len)
    ema1 + (ema1 - ema2)

// Göreceli Gücün Sýfýr Gecikmeli Trendi
float zlema_rs = f_zlema(rs_hl2, zLen)

// ─────────────────────────────────────────────────────────────────
// 4. EKRAN ÇÝZÝMÝ VE KOKPÝT (HUD)
// ─────────────────────────────────────────────────────────────────
// Hisse endeksten güçlü mü (ZLEMA'nýn üstünde mi)?
bool isStrong = rs_c > zlema_rs

color bullColor = color.new(#00e676, 0) // Neon Yeþil (Güçlü)
color bearColor = color.new(#ff1744, 0) // Kan Kýrmýzý (Zayýf)
color candleColor = isStrong ? bullColor : bearColor

// Sentetik RS Mumlarýný Çiz
plotcandle(rs_o, rs_h, rs_l, rs_c, title="RS Mumlarý", color=candleColor, wickcolor=candleColor, bordercolor=candleColor)

// ZLEMA Kinetik Ývme Çizgisi
//plot(zlema_rs, color=color.white, title="Z-RS Motoru", linewidth=2)

// ─────────────────────────────────────────────────────────────────
// 5. DURUM TABLOSU
// ─────────────────────────────────────────────────────────────────
var table tbl = table.new(position.top_right, 1, 2, bgcolor=color.new(color.black, 80), border_color=color.new(color.white, 20), border_width=1)

if barstate.islast
    string status = isStrong ? "💪 OLUMLU" : "🩸 OLUMSUZ"
    table.cell(tbl, 0, 0, syminfo.ticker + " / " + syminfo.ticker(symB), text_color=color.white, text_size=size.small)
    table.cell(tbl, 0, 1, status, text_color=candleColor, text_size=size.small, text_formatting=text.format_bold) 

[@yörük@]

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

//@version=6
indicator('korelasyon', overlay = true, format = format.price, max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, max_bars_back = 5000)
import Trendoscope/ZigzagLite/4 as zg

const string visualG = 'Display ________________________________________________________'
const string configG = 'Configuration ________________________________________________________'
const string configSMTG = 'Configuration - SMT ________________________________________________________'

type configSMT
    int len

    bool useSymbolA
    string symbolA

    bool useSymbolB
    string symbolB

type configGen
    bool detectionShow
    string sensitivity
    int memoryBufferSize
    bool deleteInvalidated
    int activeSMTMaxAge
    int confirmedSMTKeepBars

type cssSMT
    color uLink
    color dLink
    int linkW
    string linkStyle

    bool showLbl
    color lblUclr
    color lblDclr
    string lblSize

configGen cfgGenSMT = configGen.new(
     input.bool(false, '↯ Show Detection', tooltip = 'This setting visualizes the process for detecting SMT divergences. It looks very cool in sped-up replay mode.', group = configG),
     input.string('High', 'Sens.', ['Abysmal', 'Low', 'Med.', 'High', 'Insane'], tooltip = 'This script uses a ZigZag algorithm to detect SMTs. This setting changes the zigzag\'s sensitivity to new pivots.', group = configG),
     input.int(6, 'Memory Buffer', minval = 6, maxval = 256, step = 2, group = configG),
     input.bool(true, 'Hide invalidated SMTs', group = configG),
     300, // input.int(300, 'debug_ActiveSMTMaxAgeBarCount', minval = 1, maxval = 5000, group = configG, tooltip = 'SMTs older than this many bars are no longer considered active.'),
     1000 // input.int(1000, 'debug_ConfirmedSMTKeepForBarCount', minval = 1, maxval = 5000, group = configG, tooltip = 'Confirmed SMTs older than this many bars are removed from memory.')
     )
     
configSMT cfgSMT = configSMT.new(
     10, // placeholder
     input.bool(true, '', group = configSMTG, inline = 'symA', confirm = true),
     input.symbol('BIST:XU100', '', group = configSMTG, inline = 'symA', confirm = true),
     input.bool(true, '', group = configSMTG, inline = 'symB', confirm = true),
     input.symbol('BIST:XU030', '', group = configSMTG, inline = 'symB', confirm = true)
     )

cssSMT cosSMT = cssSMT.new(
     input.color(color.new(#f6f6f8, 0), 'Link —    ', group = visualG, inline = 'link'),
     input.color(color.new(#f7a502, 0), '', group = visualG, inline = 'link'),
     input.int(1, '', group = visualG, inline = 'link'),
     input.string('solid', '', group = visualG, inline = 'link', options = ['solid', 'dashed', 'dotted']),

     input.bool(false, 'Label', group = visualG, inline = 'lbl'),
     input.color(color.new(#8fadff, 75), '', group = visualG, inline = 'lbl'),
     input.color(color.new(#ffffff, 75), '', group = visualG, inline = 'lbl'),
     input.string('tiny', '', group = visualG, inline = 'lbl', options = ['tiny', 'small', 'normal', 'large', 'huge'])
     )

sensLen = switch cfgGenSMT.sensitivity
    'Abysmal' => 72
    'Low' => 32
    'Med.' => 12
    'High' => 6
    'Insane' => 2
    => 10 //
    

var zg.Zigzag smtMainZZ = zg.Zigzag.new(sensLen, cfgGenSMT.memoryBufferSize)
smtMainZZ.calculate()

var polyline analysisPL = na
var array<label> analysisDots = array.new<label>()

smtPvtArray = smtMainZZ.zigzagPivots

if cfgGenSMT.detectionShow
    if array.size(analysisDots) > 0
        for i = 0 to array.size(analysisDots) - 1
            analysisDots.get(i).delete()
        array.clear(analysisDots)

    if array.size(smtPvtArray) > 0
        for i = 0 to array.size(smtPvtArray) - 1
            pvt = smtPvtArray.get(i)
            pvtDir = pvt.dir

            analysisDot = label.new(
                 xloc = xloc.bar_index,
                 x = pvt.point.index,
                 y = pvt.point.price, 
                 style = label.style_circle,
                 text = str.tostring(i),
                 size = size.tiny,
                 color = math.sign(pvtDir) == 1 ? cosSMT.lblDclr : cosSMT.lblUclr)

            array.push(analysisDots, analysisDot)
    
method stripPrefix(string sym) =>
    int colon = str.pos(sym, ":")
    colon != -1 ? str.substring(sym, colon + 1) : sym

externalHi  = request.security(cfgSMT.symbolA, timeframe.period, high)
externalLo  = request.security(cfgSMT.symbolA, timeframe.period, low)
externalHiB = request.security(cfgSMT.symbolB, timeframe.period, high)
externalLoB = request.security(cfgSMT.symbolB, timeframe.period, low)

isDivergenceA() =>
    smtOK = false
    zg.Pivot pvtNewest     = na
    float pvtNewestPrice   = na
    zg.Pivot pvtOlder      = na
    float pvtOlderPrice    = na
    zg.Pivot pvtIntermediate = na
    if cfgSMT.useSymbolA and smtPvtArray.size() >= 4
        for i = 2 to smtPvtArray.size() - 1 by 2
            pvtNewest      := smtPvtArray.first()
            pvtNewestPrice := pvtNewest.point.price
            pvtOlder       := smtPvtArray.get(i)
            pvtOlderPrice  := pvtOlder.point.price

            pvtIntermediate := smtPvtArray.get(1)

            float pvtNewestComparePrice = na
            float pvtOlderComparePrice = na

            if math.sign(pvtNewest.dir) != math.sign(pvtOlder.dir)
                runtime.error('logic error: pivot directions dont match')
            else if math.sign(pvtNewest.dir) == 1
                pvtNewestComparePrice := externalHi[bar_index - pvtNewest.point.index]
                pvtOlderComparePrice  := externalHi[bar_index - pvtOlder.point.index]
            else if math.sign(pvtNewest.dir) == -1
                pvtNewestComparePrice := externalLo[bar_index - pvtNewest.point.index]
                pvtOlderComparePrice  := externalLo[bar_index - pvtOlder.point.index]

            if not na(pvtNewestComparePrice) and not na(pvtOlderComparePrice)
                if ((pvtNewestPrice > pvtOlderPrice) and not (pvtNewestComparePrice > pvtOlderComparePrice)) or ((pvtNewestPrice < pvtOlderPrice) and not (pvtNewestComparePrice < pvtOlderComparePrice))
                    log.info('SMT@{0} x {1}:A :pvtNewestPrice: {2} | pvtOlderPrice: {3} and pvtNewestComparePrice: {4} | pvtOlderComparePrice: {5}', 0, i, pvtNewestPrice, pvtOlderPrice, pvtNewestComparePrice, pvtOlderComparePrice)
                    log.info('size: {0}', i / 2)
                    smtOK := true
                    if (i > 2)
                        log.info('checking invl')
                        for j = 2 to i -1 by 2
                            pvtC = smtPvtArray.get(j)
                            if math.sign(pvtNewest.dir) == 1 and (pvtC.point.price > math.min(pvtNewestPrice, pvtOlderPrice))
                                log.info('^invalidated at {0}', j)
                                smtOK := false
                                break
                            else if math.sign(pvtNewest.dir) == -1 and (pvtC.point.price < math.max(pvtNewestPrice, pvtOlderPrice))
                                log.info('^invalidated at {0}', j)
                                smtOK := false
                                break
            if smtOK
                break
    [smtOK, pvtNewest, pvtOlder, pvtIntermediate]

isDivergenceB() =>
    smtOK = false
    zg.Pivot pvtNewest     = na
    float pvtNewestPrice   = na
    zg.Pivot pvtOlder      = na
    float pvtOlderPrice    = na
    zg.Pivot pvtIntermediate = na
    if cfgSMT.useSymbolB and smtPvtArray.size() >= 4
        for i = 2 to smtPvtArray.size() - 1 by 2
            pvtNewest      := smtPvtArray.first()
            pvtNewestPrice := pvtNewest.point.price
            pvtOlder       := smtPvtArray.get(i)
            pvtOlderPrice  := pvtOlder.point.price

            pvtIntermediate := smtPvtArray.get(1)

            float pvtNewestComparePrice = na
            float pvtOlderComparePrice = na

            if math.sign(pvtNewest.dir) != math.sign(pvtOlder.dir)
                runtime.error('logic error: pivot directions dont match')
            else if math.sign(pvtNewest.dir) == 1
                pvtNewestComparePrice := externalHiB[bar_index - pvtNewest.point.index]
                pvtOlderComparePrice  := externalHiB[bar_index - pvtOlder.point.index]
            else if math.sign(pvtNewest.dir) == -1
                pvtNewestComparePrice := externalLoB[bar_index - pvtNewest.point.index]
                pvtOlderComparePrice  := externalLoB[bar_index - pvtOlder.point.index]

            if not na(pvtNewestComparePrice) and not na(pvtOlderComparePrice)
                if ((pvtNewestPrice >= pvtOlderPrice) and not (pvtNewestComparePrice >= pvtOlderComparePrice)) or ((pvtNewestPrice <= pvtOlderPrice) and not (pvtNewestComparePrice <= pvtOlderComparePrice))
                    log.info('SMT@{0} x {1}:B, :pvtNewestPrice: {2} | pvtOlderPrice: {3} and pvtNewestComparePrice: {4} | pvtOlderComparePrice: {5}', 0, i, pvtNewestPrice, pvtOlderPrice, pvtNewestComparePrice, pvtOlderComparePrice)
                    log.info('size: {0}', i / 2)
                    smtOK := true
                    if (i > 2)
                        for j = 2 to i -1 by 2
                            pvtC = smtPvtArray.get(j)
                            if math.sign(pvtNewest.dir) == 1 and (pvtC.point.price > math.min(pvtNewestPrice, pvtOlderPrice))
                                log.info('^invalidated at {0}', j)
                                smtOK := false
                                break
                            else if math.sign(pvtNewest.dir) == -1 and (pvtC.point.price < math.max(pvtNewestPrice, pvtOlderPrice))
                                log.info('^invalidated at {0}', j)
                                smtOK := false
                                break
            if smtOK
                break
    [smtOK, pvtNewest, pvtOlder, pvtIntermediate]

[isCurrentSMTA, pvtNewestA, pvtOlderA, pvtIntermediateA] = isDivergenceA()
[isCurrentSMTB, pvtNewestB, pvtOlderB, pvtIntermediateB] = isDivergenceB()

type smtLinkCalc
    chart.point anchorA
    chart.point anchorB
    chart.point anchorZ
    string symbol
    float dir

    bool invalidated
    int invalidationIndex = na
    bool validated
    int validationIndex = na

type confirmedArraySwitcher
    array<smtLinkCalc> chart 
    array<smtLinkCalc> other 

varip smtRawArrA = array.new<smtLinkCalc>()
varip smtRawArrB = array.new<smtLinkCalc>()
varip smtConfirmedArrA = confirmedArraySwitcher.new(chart = array.new<smtLinkCalc>(), other = array.new<smtLinkCalc>())
varip smtConfirmedArrB = confirmedArraySwitcher.new(chart = array.new<smtLinkCalc>(), other = array.new<smtLinkCalc>())

calcSMT(isCurrentSMT, pvtNewest, pvtOlder, pvtIntermediate, symbol, array<smtLinkCalc> smtRawArr) =>
    if isCurrentSMT and bar_index > (last_bar_index - 2500) and not na(pvtNewest) and not na(pvtOlder)
        anchorA = chart.point.new(0, pvtNewest.point.index, pvtNewest.point.price)
        anchorB = chart.point.new(0, pvtOlder.point.index, pvtOlder.point.price)
        anchorZ = chart.point.new(0, pvtIntermediate.point.index, pvtIntermediate.point.price)

        smtRawArr.push(smtLinkCalc.new(anchorA, anchorB, anchorZ, symbol, -math.sign(pvtNewest.dir)))

calcSMT(isCurrentSMTA, pvtNewestA, pvtOlderA, pvtIntermediateA, 'A', smtRawArrA)
calcSMT(isCurrentSMTB, pvtNewestB, pvtOlderB, pvtIntermediateB, 'B', smtRawArrB)

confirmSMT(array<smtLinkCalc> smtRawArr, confirmedArraySwitcher smtConfirmedArrSw) =>
    if smtRawArr.size() > 0
        rSmt = smtRawArr.last()
        rAP = rSmt.anchorA.price
        rBP = rSmt.anchorB.price
        if ((smtConfirmedArrSw.chart.size() < 1) or (smtConfirmedArrSw.other.size() < 1))
            if (rSmt.dir == 1 and rAP < rBP) or
                 (rSmt.dir == -1 and rAP > rBP) and
                 smtConfirmedArrSw.chart.size() < 1
                smtConfirmedArrSw.chart.push(rSmt)
            else if smtConfirmedArrSw.other.size() < 1
                smtConfirmedArrSw.other.push(rSmt)
            smtRawArr.clear()
        else if smtRawArr.size() > 0
            for smt in smtRawArr
                aP = smt.anchorA.price
                bP = smt.anchorB.price
                lastConfirmedSMT = (smt.dir == 1 and aP < bP) or (smt.dir == -1 and aP > bP) ? smtConfirmedArrSw.chart.last() : smtConfirmedArrSw.other.last() 
                if (smt.dir == 1 and aP < bP) or 
                     (smt.dir == -1 and aP > bP)
                    if smt.anchorB.index != lastConfirmedSMT.anchorB.index
                        log.info('{0} != {1}', smt.anchorB.index, lastConfirmedSMT.anchorB.index)
                        smtConfirmedArrSw.chart.push(smt)
                    else
                        smtConfirmedArrSw.chart.pop()
                        smtConfirmedArrSw.chart.push(smt)
                else
                    if smt.anchorB.index != lastConfirmedSMT.anchorB.index
                        log.info('{0} != {1}', smt.anchorB.index, lastConfirmedSMT.anchorB.index)
                        smtConfirmedArrSw.other.push(smt)
                    else
                        smtConfirmedArrSw.other.pop()
                        smtConfirmedArrSw.other.push(smt)
            smtRawArr.clear()

confirmSMT(smtRawArrA, smtConfirmedArrA)
confirmSMT(smtRawArrB, smtConfirmedArrB)

type smtLinkDraw
    smtLinkCalc data
    line link
    label lbl
    line linkInvalidation
    line linkValidation

var smtDrawArrA = array.new<smtLinkDraw>()
var smtDrawArrB = array.new<smtLinkDraw>()

if smtDrawArrA.size() > 0
    for i = 0 to array.size(smtDrawArrA) - 1
        smtDrawArrA.get(i).link.delete()
        smtDrawArrA.get(i).lbl.delete()
        smtDrawArrA.get(i).linkInvalidation.delete()
    array.clear(smtDrawArrA)

if smtDrawArrB.size() > 0
    for i = 0 to array.size(smtDrawArrB) - 1
        smtDrawArrB.get(i).link.delete()
        smtDrawArrB.get(i).lbl.delete()
        smtDrawArrB.get(i).linkInvalidation.delete()
    array.clear(smtDrawArrB)

drawSMT(smtLinkCalc linkCalc) =>
    if not na(linkCalc)
        string style = switch cosSMT.linkStyle
            'solid'  => line.style_solid
            'dashed' => line.style_dashed
            'dotted' => line.style_dotted
            => line.style_solid

        string size = switch cosSMT.lblSize
            'tiny'   => size.tiny
            'small'  => size.small
            'normal' => size.normal
            'large'  => size.large
            'huge'   => size.large
            => size.tiny

        string labelText = na

        if linkCalc.dir == 1
            labelText := linkCalc.symbol == 'A' ? cfgSMT.symbolA.stripPrefix() : linkCalc.symbol == 'B' ? cfgSMT.symbolB.stripPrefix() + '\n' : ''
        else if linkCalc.dir == -1
            labelText := linkCalc.symbol == 'A' ? cfgSMT.symbolA.stripPrefix() : linkCalc.symbol == 'B' ? '\n' + cfgSMT.symbolB.stripPrefix() : ''

        link = line.new(
            chart.point.from_index(linkCalc.anchorA.index, linkCalc.anchorA.price + syminfo.mintick * 5 * -math.sign(linkCalc.dir)),
            chart.point.from_index(linkCalc.anchorB.index, linkCalc.anchorB.price + syminfo.mintick * 5 * -math.sign(linkCalc.dir)),
            color = linkCalc.invalidated ? cfgGenSMT.deleteInvalidated ? color.new(color.black, 100) : color.new(color.red, 50) : linkCalc.dir == 1 ? cosSMT.uLink : cosSMT.dLink,
            width = cosSMT.linkW,
            style = style)

        aP = linkCalc.anchorA.price
        bP = linkCalc.anchorB.price
        zP = linkCalc.anchorZ.price

        invalidated = linkCalc.invalidated

        line linkInvalidation = na
        if (linkCalc.dir == 1 and aP < bP) or 
             (linkCalc.dir == -1 and aP > bP)
            linkInvalidation := line.new(
                linkCalc.anchorB,
                chart.point.from_index(invalidated ? linkCalc.invalidationIndex : linkCalc.anchorA.index + 2, linkCalc.anchorB.price),
                color = cfgGenSMT.deleteInvalidated ? color.new(color.black, 100) : color.new(color.gray, 25),
                width = cosSMT.linkW,
                style = line.style_dotted
            )

        line linkValidation = na
        if (linkCalc.dir == 1 and aP < bP) or
             (linkCalc.dir == -1 and aP > bP)
            linkValidation := line.new(
                linkCalc.anchorZ,
                chart.point.from_index(linkCalc.anchorA.index + 2, linkCalc.anchorZ.price),
                color = cfgGenSMT.deleteInvalidated ? color.new(color.black, 100): color.new(color.white, 25),
                width = cosSMT.linkW,
                style = line.style_dotted
            )
            
        lblChartPoint = chart.point.from_index((linkCalc.anchorA.index + linkCalc.anchorB.index) / 2, ((linkCalc.anchorA.price + linkCalc.anchorB.price) / 2 + syminfo.mintick * 5 * -math.sign(linkCalc.dir)))
        lbl = cosSMT.showLbl ? label.new(
            lblChartPoint,
            text = labelText,
            color = color.new(color.black, 100),
            textcolor = (cfgGenSMT.deleteInvalidated and linkCalc.invalidated) ? color.new(color.black, 100) : linkCalc.dir == 1 ? color.new(cosSMT.lblUclr, 10) : color.new(cosSMT.lblDclr, 10),
            style = linkCalc.dir == -1 ? label.style_label_down : label.style_label_up,
            size = size,
            text_font_family = font.family_monospace
        ) : na

        smtLinkDraw.new(linkCalc, link, lbl, linkInvalidation)


// log.info('smtConfirmedArrA.size() = {0} and {1}', smtConfirmedArrA.chart.size(), smtConfirmedArrA.other.size())
// log.info('smtRawArrA.size() = {0}', smtRawArrA.size())
// log.info('smtConfirmedArrB.size() = {0} and {1}', smtConfirmedArrB.chart.size(), smtConfirmedArrB.other.size())
// log.info('smtRawArrB.size() = {0}', smtRawArrB.size())

method priceHit(float this, float hi, float lo) =>
    (hi >= this and lo <= this)

method pruneConfirmedSMTArray(array<smtLinkCalc> smtArr, int keepBars) =>
    if smtArr.size() > 0
        for i = smtArr.size() - 1 to 0 by 1
            smtD = smtArr.get(i)
            newestAnchorIndex = math.max(smtD.anchorA.index, smtD.anchorB.index, smtD.anchorZ.index)
            if bar_index - newestAnchorIndex > keepBars
                smtArr.remove(i)

method checkInvalidation(array<smtLinkCalc> smtArr, symbol) =>
    if smtArr.size() > 0
        symHigh = request.security(symbol, timeframe.period, high)
        symLow = request.security(symbol, timeframe.period, low)
        for i = 0 to smtArr.size() - 1
            smtD = smtArr.get(i)
            aP = smtD.anchorA.price
            bP = smtD.anchorB.price
            topDot = math.sign(smtD.dir) == 1
            aPS = topDot ? symHigh[bar_index - smtD.anchorA.index] : symLow[bar_index - smtD.anchorA.index]
            bPS = topDot ? symHigh[bar_index - smtD.anchorB.index] : symLow[bar_index - smtD.anchorB.index]
            if ((smtD.dir == 1 and aP < bP and high > bP) or 
                 (smtD.dir == -1 and aP > bP and low < bP)) and not (smtD.invalidated or smtD.validated)
                log.info('smt invalidation')
                smtD.invalidationIndex := bar_index
                smtD.invalidated := true
            else if ((smtD.dir == 1 and aPS < bPS and symHigh > bPS) or
                 (smtD.dir == -1 and aPS > bPS and symLow < bPS)) and not (smtD.invalidated or smtD.validated)
                log.info('smt invalidation')
                smtD.invalidated := true

method checkValidation(array<smtLinkCalc> smtArr, symbol) =>
    if smtArr.size() > 0
        symHigh = request.security(symbol, timeframe.period, high)
        symLow = request.security(symbol, timeframe.period, low)
        symClose = request.security(symbol, timeframe.period, close)
        for i = 0 to smtArr.size() - 1
            smtD = smtArr.get(i)
            aP = smtD.anchorA.price
            bP = smtD.anchorB.price
            zP = smtD.anchorZ.price
            topDot = math.sign(smtD.dir) == 1
            aPS = topDot ? symHigh[bar_index - smtD.anchorA.index] : symLow[bar_index - smtD.anchorA.index]
            bPS = topDot ? symHigh[bar_index - smtD.anchorB.index] : symLow[bar_index - smtD.anchorB.index]
            zPS = topDot ? symHigh[bar_index - smtD.anchorZ.index] : symLow[bar_index - smtD.anchorZ.index]
            if ((smtD.dir == 1 and aP < bP and close < zP) or
                (smtD.dir == -1 and aP > bP and close > zP)) and not (smtD.invalidated or smtD.validated)
                log.info('smt validated')
                smtD.validationIndex := bar_index
                smtD.validated := true
            else if ((smtD.dir == 1 and aPS < bPS and symClose < zPS) or 
                (smtD.dir == -1 and aPS > bPS and symClose > zPS)) and not (smtD.invalidated or smtD.validated)
                log.info('smt validated')
                smtD.validated := true
            
smtConfirmedArrA.chart.checkInvalidation(cfgSMT.symbolA)
smtConfirmedArrA.chart.checkValidation(cfgSMT.symbolA)
smtConfirmedArrA.other.checkInvalidation(cfgSMT.symbolA)
smtConfirmedArrA.other.checkValidation(cfgSMT.symbolA)
smtConfirmedArrB.chart.checkInvalidation(cfgSMT.symbolB)
smtConfirmedArrB.chart.checkValidation(cfgSMT.symbolB)
smtConfirmedArrB.other.checkInvalidation(cfgSMT.symbolB)
smtConfirmedArrB.other.checkValidation(cfgSMT.symbolB)

smtConfirmedArrA.chart.pruneConfirmedSMTArray(cfgGenSMT.confirmedSMTKeepBars)
smtConfirmedArrA.other.pruneConfirmedSMTArray(cfgGenSMT.confirmedSMTKeepBars)
smtConfirmedArrB.chart.pruneConfirmedSMTArray(cfgGenSMT.confirmedSMTKeepBars)
smtConfirmedArrB.other.pruneConfirmedSMTArray(cfgGenSMT.confirmedSMTKeepBars)

if smtConfirmedArrA.chart.size() > 0
    for i = 0 to smtConfirmedArrA.chart.size() -1
        smtDrawArrA.push(drawSMT(smtConfirmedArrA.chart.get(i)))
if smtConfirmedArrA.other.size() > 0
    for i = 0 to smtConfirmedArrA.other.size() -1
        smtDrawArrA.push(drawSMT(smtConfirmedArrA.other.get(i)))

if smtConfirmedArrB.chart.size() > 0
    for i = 0 to smtConfirmedArrB.chart.size() -1
        smtDrawArrB.push(drawSMT(smtConfirmedArrB.chart.get(i)))
if smtConfirmedArrB.other.size() > 0
    for i = 0 to smtConfirmedArrB.other.size() -1
        smtDrawArrB.push(drawSMT(smtConfirmedArrB.other.get(i)))

type smtFlag
    int activeSMTCount
    array<smtLinkCalc> activeSMTArr

smtFlagA = smtFlag.new(0, array.new<smtLinkCalc>())
smtFlagB = smtFlag.new(0, array.new<smtLinkCalc>())

updateActiveSMTFlag(confirmedArraySwitcher smtConfirmedArrSw, smtFlag smtFlagObj) =>
    array.clear(smtFlagObj.activeSMTArr)

    if smtConfirmedArrSw.chart.size() > 0
        for smt in smtConfirmedArrSw.chart
            newestAnchorIndex = math.max(smt.anchorA.index, smt.anchorB.index, smt.anchorZ.index)
            isFresh = bar_index - newestAnchorIndex <= cfgGenSMT.activeSMTMaxAge
            if isFresh and not smt.invalidated and not smt.validated
                array.push(smtFlagObj.activeSMTArr, smt)

    if smtConfirmedArrSw.other.size() > 0
        for smt in smtConfirmedArrSw.other
            newestAnchorIndex = math.max(smt.anchorA.index, smt.anchorB.index, smt.anchorZ.index)
            isFresh = bar_index - newestAnchorIndex <= cfgGenSMT.activeSMTMaxAge
            if isFresh and not smt.invalidated and not smt.validated
                array.push(smtFlagObj.activeSMTArr, smt)

    smtFlagObj.activeSMTCount := array.size(smtFlagObj.activeSMTArr)

updateActiveSMTFlag(smtConfirmedArrA, smtFlagA)
updateActiveSMTFlag(smtConfirmedArrB, smtFlagB)