Elliott Wave Impulse 12345, ABC & Fibonacci Targets

indicator("Elliott Wave Impulse 12345, ABC & Fibonacci Targets", "Elliott Wave",
     overlay = true, max_lines_count = 300, max_labels_count = 400, max_polylines_count = 80)

gC = "Count"
side   = input.string("Both", "Direction", options = ["Both", "Bullish", "Bearish"], group = gC)
pivLen = input.int(5, "Swing strength", minval = 2, maxval = 20, group = gC, tooltip = "Bars on each side that confirm a swing. Higher = larger waves.")
legMin = input.float(1.5, "Min. swing size (× ATR)", minval = 0.5, maxval = 10.0, step = 0.1, group = gC, tooltip = "Smaller moves against the current swing are ignored.")
w1Min  = input.float(4.0, "Min. wave 1 (× ATR)", minval = 1.0, maxval = 20.0, step = 0.5, group = gC)
w3Min  = input.float(1.0, "Min. wave 3 (× wave 1)", minval = 0.5, maxval = 3.0, step = 0.1, group = gC, tooltip = "A swing beyond wave 1 counts as the end of wave 3 only if wave 3 is at least this large.")
r2Min  = input.float(0.382, "Wave 2 min. retracement", minval = 0.1, maxval = 0.8, step = 0.01, group = gC)
r2Max  = input.float(0.886, "Wave 2 max. retracement", minval = 0.5, maxval = 0.99, step = 0.01, group = gC,
     tooltip = "Applies when the count starts. Rule 1 still allows a later, deeper wave 2 as long as the start of wave 1 holds.")
maxAge = input.int(600, "Count expiry (bars)", minval = 100, maxval = 3000, group = gC)

gD = "Drawing"
showPath = input.bool(true, "Draw the wave path", group = gD)
showTgt  = input.bool(true, "Fibonacci targets and invalidation", group = gD)
showRat  = input.bool(true, "Measured ratio on wave labels", group = gD)
keepN    = input.int(3, "Counts drawn", minval = 1, maxval = 20, group = gD, tooltip = "Finished counts older than this are removed from the chart. The record keeps all of them.")
lblSize  = input.string("Normal", "Label size", options = ["Small", "Normal", "Large"], group = gD)

gP = "Panel"
showTbl = input.bool(true, "Show panel", group = gP)
tblPos  = input.string("Top Right", "Position", options = ["Top Right", "Bottom Right", "Top Left", "Bottom Left"], group = gP)
tblSize = input.string("Normal", "Text size", options = ["Small", "Normal", "Large"], group = gP)

gA = "Alerts"
alWave = input.bool(true, "Alert: wave 3 confirmed and each finished wave", group = gA)
alEnd  = input.bool(true, "Alert: impulse complete / ABC complete / rule broken", group = gA)

candOn_ = input.bool(true, "Neon candles", group = "Visuals")
candGlw = input.bool(true, "Glow candles", group = "Visuals", tooltip = "Each body is drawn in four bands that brighten towards the close, so the candle reads in the direction it moved. Off = flat translucent bodies.")

bgLum   = 0.2126 * color.r(chart.bg_color) + 0.7152 * color.g(chart.bg_color) + 0.0722 * color.b(chart.bg_color)
isLight = bgLum > 128
UP    = isLight ? #6D4FE0 : #A58BFF   // ultraviolet: bullish impulse
DN    = isLight ? #D91E50 : #FF5E7E   // rose: bearish impulse
ACC   = isLight ? #0E9488 : #5CF2E6   // aqua: A-B-C correction
GREY  = isLight ? #8A8F9C : #5F5A70
TXT   = isLight ? #1A1626 : #F0EDF7
MUTE  = isLight ? #625C72 : #A29BB5
PANEL = isLight ? #FFFFFF : #0E0A18
ROW   = isLight ? #F3F0FA : #1A1428
INK   = #0E0A18
NONE  = color.new(color.black, 100)

lSize = lblSize == "Small" ? size.small : lblSize == "Large" ? size.large : size.normal
tSize = tblSize == "Small" ? size.small : tblSize == "Large" ? size.large : size.normal

px(float v) =>
    str.tostring(v, format.mintick)

pct(int a, int b) =>
    b > 0 ? str.tostring(a * 100.0 / b, "0") + "%" : "—"

atr  = ta.atr(50)
ph   = ta.pivothigh(high, pivLen, pivLen)
pl   = ta.pivotlow(low, pivLen, pivLen)
pBar = bar_index - pivLen

var int  stage = 0
var int  reach = 0
var int  dir   = 0
var bool brk   = false     // a close beyond the end of wave 1 confirmed wave 3

var array<float>    zP = array.new_float()     // zigzag of confirmed swings
var array<int>      zB = array.new_int()
var array<bool>     zH = array.new_bool()

var array<float>    wv = array.new_float(9, na)
var array<int>      wb = array.new_int(9, na)
var array<label>    wL = array.new<label>(9, na)
var array<polyline> pP = array.new<polyline>(4, na)

var array<line>   tLn  = array.new<line>(2, na)
var array<label>  tLb  = array.new<label>(2, na)
var array<float>  tY   = array.new_float(2, na)
var array<bool>   tHit = array.new_bool(2, false)
var array<int>    tD   = array.new_int(1, 0)
var array<line>   iLn  = array.new<line>(1, na)
var array<label>  iLb  = array.new<label>(1, na)

var array<int>   rN    = array.new_int(2, 0)
var array<int>   r5    = array.new_int(2, 0)
var array<int>   rC    = array.new_int(2, 0)
var array<int>   rFail = array.new_int(2, 0)
var array<float> sW   = array.new_float(9, 0.0)  // sum of each wave's ratio, indexed like the points
var array<int>   nW   = array.new_int(9, 0)

evStart = false
evBreak = false
evW     = 0
evImp   = false
evDone  = false
evFail  = false
evExp   = false
evDrop  = false
failTxt = ""

bumpI(array<int> a, int i, int add) =>
    array.set(a, i, array.get(a, i) + add)
bumpF(array<float> a, int i, float add) =>
    array.set(a, i, array.get(a, i) + add)

var int mId = 0
var array<label>    gLb  = array.new<label>()
var array<int>      gLbI = array.new_int()
var array<polyline> gPl  = array.new<polyline>()
var array<int>      gPlI = array.new_int()

regLb(label o) =>
    array.push(gLb, o)
    array.push(gLbI, mId)
regPl(polyline o) =>
    array.push(gPl, o)
    array.push(gPlI, mId)

prune(int upTo) =>
    while array.size(gLbI) > 0 and array.get(gLbI, 0) <= upTo
        label.delete(array.shift(gLb))
        array.shift(gLbI)
    while array.size(gPlI) > 0 and array.get(gPlI, 0) <= upTo
        polyline.delete(array.shift(gPl))
        array.shift(gPlI)

dropTail(int id) =>
    while array.size(gLbI) > 0 and array.last(gLbI) == id
        label.delete(array.pop(gLb))
        array.pop(gLbI)
    while array.size(gPlI) > 0 and array.last(gPlI) == id
        polyline.delete(array.pop(gPl))
        array.pop(gPlI)

P(int i) =>
    array.get(wv, i)

leg(int a, int b) =>
    math.abs(P(a) - P(b))

waveRatio(int i) =>
    float r = na
    if i == 2
        r := leg(2, 1) / leg(1, 0)
    else if i == 3
        r := leg(3, 2) / leg(1, 0)
    else if i == 4
        r := leg(4, 3) / leg(3, 2)
    else if i == 5
        r := leg(5, 4) / leg(1, 0)
    else if i == 6
        r := leg(6, 5) / leg(5, 0)
    else if i == 7
        r := leg(7, 6) / leg(6, 5)
    else if i == 8
        r := leg(8, 7) / leg(6, 5)
    r

waveTxt(int i) =>
    name = i <= 5 ? str.tostring(i) : i == 6 ? "A" : i == 7 ? "B" : "C"
    r = waveRatio(i)
    showRat and not na(r) ? name + " · " + str.tostring(r, "0.00") : name

setPt(int i, float p, int b) =>
    array.set(wv, i, p)
    array.set(wb, i, b)
    lb = array.get(wL, i)
    txt = waveTxt(i)
    if na(lb)
        isHighPt = (i % 2 == 1) == (dir == 1)
        c = i == 0 ? GREY : i <= 5 ? (dir == 1 ? UP : DN) : ACC
        nl = label.new(b, p, txt, style = isHighPt ? label.style_label_down : label.style_label_up, color = c, textcolor = i == 0 ? color.white : INK, size = lSize)
        regLb(nl)
        array.set(wL, i, nl)
    else
        label.set_xy(lb, b, p)
        label.set_text(lb, txt)

clearPt(int i) =>
    label.delete(array.get(wL, i))
    array.set(wL, i, na)
    array.set(wv, i, na)
    array.set(wb, i, na)

redrawPath(int upTo) =>
    for k = 0 to 3
        polyline.delete(array.get(pP, k))
        array.set(pP, k, na)
    if showPath
        c = dir == 1 ? UP : DN
        a1 = array.new<chart.point>()
        for k = 0 to math.min(upTo, 5)
            array.push(a1, chart.point.from_index(array.get(wb, k), P(k)))
        g1 = polyline.new(a1, line_color = color.new(c, 86), line_width = 8)
        l1 = polyline.new(a1, line_color = color.new(c, 5), line_width = 2)
        regPl(g1)
        regPl(l1)
        array.set(pP, 0, g1)
        array.set(pP, 1, l1)
        if upTo > 5
            a2 = array.new<chart.point>()
            for k = 5 to upTo
                array.push(a2, chart.point.from_index(array.get(wb, k), P(k)))
            g2 = polyline.new(a2, line_color = color.new(ACC, 86), line_width = 8)
            l2 = polyline.new(a2, line_color = color.new(ACC, 5), line_width = 2, line_style = line.style_dashed)
            regPl(g2)
            regPl(l2)
            array.set(pP, 2, g2)
            array.set(pP, 3, l2)

clearT() =>
    for k = 0 to 1
        line.delete(array.get(tLn, k))
        label.delete(array.get(tLb, k))
        array.set(tLn, k, na)
        array.set(tLb, k, na)
        array.set(tY, k, na)
        array.set(tHit, k, false)
    line.delete(array.get(iLn, 0))
    label.delete(array.get(iLb, 0))
    array.set(iLn, 0, na)
    array.set(iLb, 0, na)

refreshT(int st) =>
    clearT()
    if showTgt and st >= 2 and st <= 7
        float y1 = na
        float y2 = na
        n1 = ""
        n2 = ""
        td = dir
        c = dir == 1 ? UP : DN
        if st == 2
            y1 := P(2) + dir * 1.618 * leg(1, 0)
            y2 := P(2) + dir * 2.618 * leg(1, 0)
            n1 := "W3 · 1.618"
            n2 := "W3 · 2.618"
        else if st == 3
            y1 := P(3) - dir * 0.382 * leg(3, 2)
            y2 := P(3) - dir * 0.5 * leg(3, 2)
            n1 := "W4 · 0.382"
            n2 := "W4 · 0.5"
            td := -dir
        else if st == 4
            y1 := P(4) + dir * 0.618 * leg(1, 0)
            y2 := P(4) + dir * leg(1, 0)
            n1 := "W5 · 0.618"
            n2 := "W5 · 1.0"
        else if st == 5
            y1 := P(5) - dir * 0.382 * leg(5, 0)
            y2 := P(5) - dir * 0.618 * leg(5, 0)
            n1 := "A · 0.382"
            n2 := "A · 0.618"
            td := -dir
            c := ACC
        else if st == 6
            y1 := P(6) + dir * 0.5 * leg(6, 5)
            y2 := P(6) + dir * 0.786 * leg(6, 5)
            n1 := "B · 0.5"
            n2 := "B · 0.786"
            c := ACC
        else
            y1 := P(7) - dir * leg(6, 5)
            y2 := P(7) - dir * 1.618 * leg(6, 5)
            n1 := "C · 1.0"
            n2 := "C · 1.618"
            td := -dir
            c := ACC
        array.set(tD, 0, td)
        array.set(tY, 0, y1)
        array.set(tY, 1, y2)
        array.set(tLn, 0, line.new(bar_index, y1, bar_index + 4, y1, color = color.new(c, 10), width = 2))
        array.set(tLn, 1, line.new(bar_index, y2, bar_index + 4, y2, color = color.new(c, 10), width = 2, style = line.style_dashed))
        array.set(tLb, 0, label.new(bar_index + 4, y1, n1 + "  " + px(y1), style = label.style_label_left, color = INK, textcolor = c, size = lSize))
        array.set(tLb, 1, label.new(bar_index + 4, y2, n2 + "  " + px(y2), style = label.style_label_left, color = INK, textcolor = c, size = lSize))
        if st <= 4
            yi = st == 2 ? P(0) : P(1)
            array.set(iLn, 0, line.new(bar_index, yi, bar_index + 4, yi, color = color.new(GREY, 10), style = line.style_dotted))
            array.set(iLb, 0, label.new(bar_index + 4, yi, (st == 2 ? "INVALID · rule 1  " : "INVALID · rule 3  ") + px(yi), style = label.style_label_left, color = INK, textcolor = MUTE, size = lSize))
var table wm = table.new(position.bottom_right, 1, 1)
if barstate.isfirst
    table.cell(wm, 0, 0, "Telegram @SimpleForexTools", text_color = color.new(color.gray, 70), text_size = size.large)

if barstate.isconfirmed and not na(atr)
    zChanged = false

    if stage == 2
        if (P(0) - close) * dir > 0
            evDrop := true
        else if not brk and (close - P(1)) * dir > 0
            brk := true
            evBreak := true
    else if stage == 3 or stage == 4
        if (P(1) - close) * dir > 0
            evFail := true
            failTxt := "✕ RULE 3 · wave 4 in wave 1"
    if stage >= 2 and not evDrop and not evFail and bar_index - array.get(wb, 0) > maxAge
        if reach >= 3
            evExp := true
        else
            evDrop := true

    if stage >= 2
        td = array.get(tD, 0)
        fav = td == 1 ? high : low
        for k = 0 to 1
            y = array.get(tY, k)
            if not na(y) and not array.get(tHit, k) and (fav - y) * td >= 0
                array.set(tHit, k, true)
                lb = array.get(tLb, k)
                label.set_text(lb, "✓ " + label.get_text(lb))

    lastIsHigh = array.size(zH) > 0 and array.last(zH)
    for i = 0 to 1
        evH = i == 0 ? not lastIsHigh : lastIsHigh
        pv = evH ? ph : pl
        if not na(pv)
            accepted = false
            n = array.size(zP)
            if n == 0
                array.push(zP, pv)
                array.push(zB, pBar)
                array.push(zH, evH)
                accepted := true
            else if array.last(zH) == evH
                if (pv - array.last(zP)) * (evH ? 1 : -1) > 0
                    array.set(zP, n - 1, pv)
                    array.set(zB, n - 1, pBar)
                    accepted := true
            else if (pv - array.last(zP)) * (evH ? 1 : -1) >= legMin * atr and pBar > array.last(zB)
                array.push(zP, pv)
                array.push(zB, pBar)
                array.push(zH, evH)
                accepted := true
                if array.size(zP) > 8
                    array.shift(zP)
                    array.shift(zB)
                    array.shift(zH)
            if accepted
                zChanged := true

            if accepted and stage >= 2 and not evDrop and not evFail and

Показано первые 50% кода (символов: 18029)