← К каталогу
Исходный код · ID 4978

Machine Learning Elliott Wave

indicator machine learning elliott wave for tradingview.pine
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Индикатор «Machine Learning Elliott Wave» отображает на графике подсчёт волн Эллиотта и проекции на основе анализа исторических паттернов. Скрипт строит семь зигзагов с разными множителями ATR (от 1,5 до 6), определяет точки разворота и проверяет соответствие текущего отсчёта правилам волн Эллиотта (коррекции 0,382–0,786, длительность волн, направление). Для каждой текущей волны индикатор ищет наиболее похожие прошлые движения методом k-ближайших соседей и показывает вероятные уровни остановки, диапазон и путь до волны 5. Все расчёты выполняются на закрытых свечах, и автор прямо указывает, что инструмент не даёт прогнозов — он лишь отображает, как вести себя похожие волны на данном графике.

На графике рисуются линии отсчёта волн, метки номеров, уровни проекций с процентными долями, полоса среднего диапазона и путь до волны 5. Легенда в углу графика поясняет текущую волну, следующий уровень и причины. Дополнительно можно отобразить похожие прошлые паттерны с их реальными координатами на истории. Всплывающие подсказки и текстовые метки помогают читать текущую ситуацию без открытия отдельных панелей.

Индикатор работает как наложение (overlay) на основном графике и не совершает торговых операций. Он использует стандартные средства Pine Script для расчёта ATR, отрисовки линий, меток, полилиний и таблиц. Встроенная таблица с ссылкой на Telegram является информационным элементом и не связана с функциональностью анализа.

Настройки программы

НастройкаОписание
sizeStr Перечень множителей ATR для зигзагов (через запятую). Каждый размер считается; показывается наибольший зигзаг, для которого есть читаемый отсчёт волн.
atrLen Длина периода для расчёта ATR (среднего истинного диапазона), который используется для определения размеров зигзагов и точек разворота.
minW Минимальная длительность волны в барах. Волны короче этого значения не учитываются в подсчёте, чтобы отсчёт оставался читаемым.
minSpan Минимальная ширина полного отсчёта от волны 0 до 5 в барах. Счёт должен быть не уже этого значения (масштабируется для незавершённых отсчётов на волне 3 или 4).
knn Количество ближайших прошлых откатов (по размеру в ATR, длине в барах и соотношению к предыдущему отрезку), из которых считается доля вероятных уровней для волн 2 и 4.
minHist Минимальное количество прошлых свингов в текущей роли, необходимое для построения проекции следующего уровня остановки. При меньшем количестве проекция не отрисовывается.
maxHist Максимальное количество сохранённых прошлых свинг-точек для каждого зигзага и роли волны. Более старые данные удаляются при превышении лимита.
colCnt Цвет линий отсчёта волн и меток номеров волн на графике.
colMod Цвет линий проекций, уровней впереди, пути до волны 5 и похожих паттернов.
colInv Цвет линии недействительного уровня и метки «invalid» / ✕, которые показывают, где отсчёт волн прерывается.
showNx При включении показывается путь до волны 5 по книге пропорций: волна 3 = 1,618 × волна 1, волна 4 = 0,382 от волны 3, волна 5 = 1,0 × волна 1.
showLg При включении отображается легенда с информацией о текущей волне, следующем уровне остановке, пояснении и причине ошибки отсчёта.
lgPos Позиция легенды на графике: верхний правый, нижний правый, верхний левый или нижний левый угол.
showTk При включении уровни, которые текущая волна уже прошла, помечаются галочкой (✓) с ценой вместо процентной доли.
showHs При включении на графике отображаются похожие прошлые свинги в тех координатах, где они произошли, с указанием, насколько далеко они ушли. Для просмотра необходимо прокрутить историю назад.
full5 При включении похожий паттерн волны 5 рисуется только если он прошёл дальше конца волны 3. При выключении любое движение после валидной волны 4 отображается как волна 5.
txtSize Размер текста для номеров волн, ценовых уровней и легенды на графике: Tiny, Small, Normal или Large.

Поиск по коду файла

indicator("Machine Learning Elliott Wave", "ML Elliott Wave", overlay = true,
     max_lines_count = 300, max_labels_count = 400, max_polylines_count = 10, max_boxes_count = 50, max_bars_back = 5000)

grpS = "Swings"
sizeStr = input.string("1.5, 2, 2.5, 3, 4, 5, 6", "Zigzag sizes, × ATR", group = grpS,
     tooltip = "A swing ends after a move against it of this many ATRs. Every size is counted; the biggest one with a count in play is shown.")
atrLen  = input.int(14, "ATR length", minval = 1, maxval = 200, group = grpS,
     tooltip = "The ATR the zigzag sizes are measured in.")
minW    = input.int(4, "Shortest wave, bars", minval = 1, maxval = 50, group = grpS,
     tooltip = "Waves shorter than this are not counted, so the count stays readable.")
minSpan = input.int(40, "Shortest full count 0-5, bars", minval = 5, maxval = 500, group = grpS,
     tooltip = "A count must be at least this wide (scaled down for counts still at wave 3 or 4).")

grpM = "Model"
knn     = input.int(9, "Similar pullbacks it learns from (waves 2 and 4)", minval = 3, maxval = 30, group = grpM,
     tooltip = "How many past pullbacks closest to this one (size in ATR, length in bars, size against the leg before) the share is counted from. Wave 3 uses all past wave-3-like legs.")
minHist = input.int(5, "Past swings it needs before it projects", minval = 3, maxval = 100, group = grpM,
     tooltip = "With fewer past swings in this role, no next stop is drawn.")
maxHist = input.int(300, "Past swings it remembers, per zigzag and role", minval = 20, maxval = 1000, group = grpM,
     tooltip = "Older swings are forgotten past this number.")

grpL = "Look"
colCnt  = input.color(#139C8A, "Count", inline = "c", group = grpL)
colMod  = input.color(#7B5CD6, "Projection", inline = "c", group = grpL)
colInv  = input.color(#D2557A, "Invalid", inline = "c", group = grpL,
     tooltip = "Count: the waves and their numbers. Projection: the next stop, the levels ahead and the path to wave 5. Invalid: the line that kills the count and the ✕.")
showNx  = input.bool(true, "Show the path to wave 5", group = grpL,
     tooltip = "Book proportions after the projected stop: wave 3 = 1.618 x wave 1, wave 4 = 0.382 of wave 3, wave 5 = 1.0 x wave 1.")
showLg  = input.bool(true, "Show the legend", group = grpL,
     tooltip = "Which wave, the next stop, why, and where the count is wrong, in words.")
lgPos   = input.string("Top right", "Legend position", options = ["Top right", "Bottom right", "Top left", "Bottom left"], group = grpL,
     tooltip = "Where on the chart the legend sits.")
showTk  = input.bool(true, "Tick the levels already reached", group = grpL,
     tooltip = "Levels the running wave already passed get a ✓ with their price instead of a share.")
showHs  = input.bool(true, "Draw the similar past swings", group = grpL,
     tooltip = "The past swings the share is counted from, drawn where they happened, each with how far it went. Scroll back to see them.")
full5   = input.bool(false, "Past swings: wave 5 only past wave 3", group = grpL,
     tooltip = "On: a past swing's wave 5 is drawn only when it went past the end of its wave 3. Off: the swing after a valid wave 4 is drawn as 5 either way.")
txtSize = input.string("Normal", "Text size", options = ["Tiny", "Small", "Normal", "Large"], group = grpL,
     tooltip = "Size of the numbers, levels and legend.")

txtSz(s) =>
    s == "Tiny" ? size.tiny : s == "Normal" ? size.normal : s == "Large" ? size.large : size.small

txtSzH(s) =>
    s == "Large" ? size.normal : s == "Normal" ? size.small : size.tiny
fmtP(p) =>
    str.tostring(p, format.mintick)
fmtR(r) =>
    str.tostring(r)

pctS(int a, int b) =>
    (b < 10 ? "~" : "") + str.tostring(math.round(10.0 * a / b) * 10) + "%"
pctV(int a, int b) =>
    math.round(10.0 * a / b) * 10
lvP(float base, float sg, float unit, float r) =>
    math.exp(math.log(base) + sg * r * unit)

type ZZ
    float k
    int   dir  = 0
    float ext  = na
    int   extB = na
    float extA = na
    array<int>   pb
    array<float> pp
    array<float> pa
    array<float> s3a
    array<float> s3b
    array<float> s3c
    array<float> s3e
    array<float> s4a
    array<float> s4b
    array<float> s4c
    array<float> s4e
    array<float> s2a
    array<float> s2b
    array<float> s2c
    array<float> s2e
    array<int>   hB
    array<float> hP
    int          hN = 0
    array<int>   gi3
    array<int>   gi2
    array<int>   gi4

newZZ(float k) =>
    ZZ.new(k = k, pb = array.new<int>(), pp = array.new<float>(), pa = array.new<float>(),
         s3a = array.new<float>(), s3b = array.new<float>(), s3c = array.new<float>(), s3e = array.new<float>(),
         s4a = array.new<float>(), s4b = array.new<float>(), s4c = array.new<float>(), s4e = array.new<float>(),
         s2a = array.new<float>(), s2b = array.new<float>(), s2c = array.new<float>(), s2e = array.new<float>(),
         hB = array.new<int>(), hP = array.new<float>(), gi3 = array.new<int>(), gi2 = array.new<int>(), gi4 = array.new<int>())

method hist(ZZ z, int x, float y) =>
    z.hB.push(x)
    z.hP.push(y)
    z.hN := z.hN + 1
    if z.hB.size() > 3000
        z.hB.shift()
        z.hP.shift()

method step(ZZ z, float a) =>
    bool np = false
    if z.dir == 0
        z.dir  := 1
        z.ext  := high
        z.extB := bar_index
        z.extA := a
        z.pb.push(bar_index)
        z.pp.push(low)
        z.hist(bar_index, low)
        z.pa.push(a)
    else if z.dir == 1
        if high > z.ext
            z.ext  := high
            z.extB := bar_index
            z.extA := a
        if z.ext - low >= z.k * a
            z.pb.push(z.extB)
            z.pp.push(z.ext)
            z.hist(z.extB, z.ext)
            z.pa.push(z.extA)
            z.dir  := -1
            z.ext  := low
            z.extB := bar_index
            z.extA := a
            np := true
    else
        if low < z.ext
            z.ext  := low
            z.extB := bar_index
            z.extA := a
        if high - z.ext >= z.k * a
            z.pb.push(z.extB)
            z.pp.push(z.ext)
            z.hist(z.extB, z.ext)
            z.pa.push(z.extA)
            z.dir  := 1
            z.ext  := high
            z.extB := bar_index
            z.extA := a
            np := true
    np

pushCap(array<float> arr, float v, int cap) =>
    arr.push(v)
    if arr.size() > cap
        arr.shift()

pushCapI(array<int> arr, int v, int cap) =>
    arr.push(v)
    if arr.size() > cap
        arr.shift()

method learn(ZZ z) =>
    n = z.pp.size()
    if n >= 4
        a  = z.pp.get(n - 4)
        b  = z.pp.get(n - 3)
        c  = z.pp.get(n - 2)
        d  = z.pp.get(n - 1)
        ba = z.pb.get(n - 4)
        bb = z.pb.get(n - 3)
        bc = z.pb.get(n - 2)
        if a > 0 and b > 0 and c > 0 and d > 0
            L1 = math.abs(math.log(b) - math.log(a))
            L2 = math.abs(math.log(c) - math.log(b))
            if L1 > 0
                pb = L2 / L1
                up = b > a
                passed = up ? d > b : d < b

                if pb >= 0.382 and pb <= 0.786 and passed and bb > ba and bc > bb
                    pushCap(z.s3a, math.abs(b - a) / z.pa.get(n - 3), maxHist)
                    pushCap(z.s3b, float(bb - ba), maxHist)
                    pushCap(z.s3c, pb, maxHist)
                    pushCap(z.s3e, math.abs(math.log(d) - math.log(c)) / L1, maxHist)
                    pushCapI(z.gi3, z.hN - 4, maxHist)
                newX = c > b ? c > math.max(a, b) : c < math.min(a, b)
                if L2 > 0 and not newX and bc > bb
                    pushCap(z.s2a, math.abs(c - b) / z.pa.get(n - 2), maxHist)
                    pushCap(z.s2b, float(bc - bb), maxHist)
                    pushCap(z.s2c, L2 / L1, maxHist)
                    pushCap(z.s2e, math.abs(math.log(c) - math.log(d)) / L2, maxHist)
                    pushCapI(z.gi2, z.hN - 3, maxHist)
                if L2 > 0 and newX and bc > bb
                    pushCap(z.s4a, math.abs(c - b) / z.pa.get(n - 2), maxHist)
                    pushCap(z.s4b, float(bc - bb), maxHist)
                    pushCap(z.s4c, L2 / L1, maxHist)
                    pushCap(z.s4e, math.abs(math.log(c) - math.log(d)) / L2, maxHist)
                    pushCapI(z.gi4, z.hN - 3, maxHist)
    if n > 10
        z.pb.shift()
        z.pp.shift()
        z.pa.shift()

method inPlay(ZZ z, int n, float px) =>
    m = z.pp.size() - n
    bool ok = m >= (n == 2 ? 1 : 0)
    if ok and n == 2
        p0 = z.pp.get(m)
        p1 = z.pp.get(m + 1)
        s  = p1 > p0 ? 1.0 : -1.0
        ok := p0 > 0 and p1 > 0 and z.pp.get(m - 1) > 0 and p1 != p0
        ok := ok and z.pb.get(m + 1) - z.pb.get(m) >= math.max(minW, int(minSpan / 5))
        ok := ok and s * (px - p0) > 0
    else if ok
        p0 = z.pp.get(m)
        p1 = z.pp.get(m + 1)
        s  = p1 > p0 ? 1.0 : -1.0
        q0 = s * p0
        q1 = s * p1
        q2 = s * z.pp.get(m + 2)
        L1 = q1 - q0
        ok := L1 > 0
        if ok
            r2 = (q1 - q2) / L1
            ok := r2 >= 0.382 and r2 <= 0.786
        if ok and n >= 4
            q3 = s * z.pp.get(m + 3)
            ok := q3 - q2 >= L1
            if ok and n >= 5
                q4 = s * z.pp.get(m + 4)
                L3 = q3 - q2
                r4 = (q3 - q4) / L3
                ok := r4 >= 0.236 and r4 <= 0.618 and q4 > q2

        if ok
            for j = m to m + n - 2
                if z.pb.get(j + 1) - z.pb.get(j) < minW
                    ok := false
            if z.pb.get(m + n - 1) - z.pb.get(m) < int(minSpan * (n - 1) / 5)
                ok := false

        if ok
            lim = n == 3 ? z.pp.get(m) : n == 4 ? z.pp.get(m + 2) : z.pp.get(m + 4)
            ok := s * (px - lim) > 0
    ok

var array<ZZ> zs = array.new<ZZ>()
if barstate.isfirst
    for part in str.split(sizeStr, ",")
        v = str.tonumber(str.trim(part))
        if not na(v) and v > 0
            zs.push(newZZ(v))

atrV = ta.atr(atrLen)
if barstate.isconfirmed and not na(atrV)
    for z in zs
        if z.step(atrV)
            z.learn()
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)

var array<line>     dL = array.new<line>()
var array<label>    dB = array.new<label>()
var array<polyline> dP = array.new<polyline>()
var array<box>      dX = array.new<box>()

clearAll() =>
    for x in dL
        x.delete()
    for x in dB
        x.delete()
    for x in dP
        x.delete()
    for x in dX
        x.delete()
    dL.clear()
    dB.clear()
    dP.clear()
    dX.clear()

addL(int x1, float y1, int x2, float y2, color c, int w, string st) =>
    dL.push(line.new(x1, y1, x2, y2, color = c, width = w, style = st))

addT(int x, float y, string t, color c, string st, string tip = "") =>
    dB.push(label.new(x, y, t, color = color.new(c, 100), textcolor = c, style = st, size = txtSz(txtSize), tooltip = tip, textalign = text.align_left))

var table lg = table.new(lgPos == "Top right" ? position.top_right : lgPos == "Bottom right" ? position.bottom_right : lgPos == "Top left" ? position.top_left : position.bottom_left, 1, 6)
lgRow(int r, string t, color c, bool big) =>
    if showLg and t != ""
        lg.cell(0, r, t, text_color = c, text_size = big ? txtSz(txtSize) : txtSize == "Large" ? size.normal : size.small, text_halign = text.align_right)
lgSet(string a, color ca, string b, color cb, string c1, string c2, string d, color cd, string e) =>
    lg.clear(0, 0, 0, 5)
    lgRow(0, a, ca, true)
    lgRow(1, b, cb, true)
    lgRow(2, c1, color.new(#6B7480, 0), false)
    lgRow(3, c2, color.new(#6B7480, 0), false)
    lgRow(4, d, cd, false)
    lgRow(5, e, color.new(#9AA3AE, 0), false)

if barstate.islast
    clearAll()

    int sel = -1
    int nSel = 0
    nz = zs.size()
    if nz > 0
        ordK = array.new<float>()
        for z in zs
            ordK.push(z.k)
        idxK = ordK.sort_indices(order.descending)
        for pass = * to *
            for ii = 0 to nz - 1
                zi = idxK.get(ii)
                z = zs.get(zi)
                for n in (pass == 0 ? array.from(5, 4, 3) : array.from(2))
                    if sel < 0 and z.inPlay(n, close)
                        sel  := zi
                        nSel := n
    if sel < 0
        lgSet("No Elliott count in play", color.gray, "Waiting for a clean 0-1-2", color.gray, "", "", "", color.gray, "")
    else
        z = zs.get(sel)
        n = nSel
        m = z.pp.size() - n
        p0 = z.pp.get(m)
        p1 = z.pp.get(m + 1)
        b0 = z.pb.get(m)
        b1 = z.pb.get(m + 1)
        up = p1 > p0
        s  = up ? 1.0 : -1.0
        wave = n

        for j = 0 to n - 1
            bj = z.pb.get(m + j)
            pj = z.pp.get(m + j)
            if j < n - 1
                addL(bj, pj, z.pb.get(m + j + 1), z.pp.get(m + j + 1), colCnt, 3, line.style_solid)
            top = (j % 2 == 1) == up
            dB.push(label.new(bj, pj, str.tostring(j), color = colCnt, textcolor = color.white, style = top ? label.style_label_down : label.style_label_up, size = txtSz(txtSize)))
        lastB = z.pb.get(m + n - 1)
        lastP = z.pp.get(m + n - 1)
        addL(lastB, lastP, bar_index, close, colCnt, 3, line.style_solid)

        inv = n <= 3 ? p0 : n == 4 ? z.pp.get(m + 2) : z.pp.get(m + 4)
        dur = math.min(math.max(8, b1 - b0), 150)   // labels can't sit more than 500 bars ahead
        x1  = bar_index + int(dur / 2) + 4
        xT  = x1 + 3
        xE  = xT + dur + 20
        addL(b0, inv, xE, inv, colInv, 1, line.style_dotted)
        invLn = dL.last()
        bool invTxt = true
        wDir = wave % 2 == 1 ? s : -s
        hdr = "Wave " + str.tostring(wave) + (wDir > 0 ? " up" : " down")
        wrong = "Wrong if " + (up ? "below " : "above ") + fmtP(inv)
        L1 = math.abs(math.log(p1) - math.log(p0))
        float base = na
        float unit = na
        float sg = na
        array<float> lv = array.new<float>()
        array<float> pool = array.new<float>()
        array<int>   poolR = array.new<int>()   // which role each swing in the pool came from
        array<int>   poolI = array.new<int>()   // and its place in that role's memory
        bool book = false
        if wave == 2
            pP = z.pp.get(m - 1)
            base := p1
            unit := L1
            sg   := -s
            lv   := array.from(0.236, 0.382, 0.5, 0.618, 0.786, 0.886)
            cnt2 = z.s2e.size()
            cnt4 = z.s4e.size()
            cnt  = cnt2 + cnt4
            if cnt >= minHist
                f1 = math.abs(p1 - p0) / z.pa.get(m + 1)
                f2 = float(b1 - b0)
                f3 = L1 / math.abs(math.log(p0) - math.log(pP))
                fa = array.new<float>()
                fb = array.new<float>()
                fc = array.new<float>()
                fe = array.new<float>()
                fa.concat(z.s2a)
                fa.concat(z.s4a)
                fb.concat(z.s2b)
                fb.concat(z.s4b)
                fc.concat(z.s2c)
                fc.concat(z.s4c)
                fe.concat(z.s2e)
                fe.concat(z.s4e)
                sd1 = fa.stdev()
                sd2 = fb.stdev()
                sd3 = fc.stdev()
                sd1 := sd1 > 0 ? sd1 : 1.0
                sd2 := sd2 > 0 ? sd2 : 1.0
                sd3 := sd3 > 0 ? sd3 : 1.0
                dist = array.new<float>()
                for i = 0 to cnt - 1
                    a1 = (fa.get(i) - f1) / sd1
                    a2 = (fb.get(i) - f2) / sd2
                    a3 = (fc.get(i) - f3) / sd3
                    dist.push(a1 * a1 + a2 * a2 + a3 * a3)
                ord = dist.sort_indices(order.ascending)
                for j = 0 to math.min(knn, cnt) - 1
                    oj = ord.get(j)
                    pool.push(fe.get(oj))
                    poolR.push(oj < cnt2 ? 2 : 4)
                    poolI.push(oj < cnt2 ? oj : oj - cnt2)
        else if wave == 3
            base := z.pp.get(m + 2)
            unit := L1
            sg   := s
            lv   := array.from(1.0, 1.272, 1.618, 2.0, 2.618)
            if z.s3e.size() >= minHist
                pool := z.s3e.copy()
                for j = 0 to pool.size() - 1
                    poolR.push(3)
                    poolI.push(j)
        else if wave == 4
            p2 = z.pp.get(m + 2)
            p3 = z.pp.get(m + 3)
            L3 = math.abs(math.log(p3) - math.log(p2))
            base := p3
            unit := L3
            sg   := -s
            lv   := array.from(0.236, 0.382, 0.5, 0.618, 0.786, 0.886)
            cnt  

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