Level Evidence Map: Fibonacci, Gann & Pivots vs Random Lines

thescalpeltrader · study · 632 行 · 点赞 1,393 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © thescalpeltrader
 
//@version=6
indicator("Level Evidence Map", shorttitle = "LEM", overlay = true, max_lines_count = 50, max_labels_count = 300, max_boxes_count = 60)
 
// ─────────────────────────────────────────────────────────────────────────────
// Level Evidence Map
// Do popular chart levels beat random lines on THIS chart?
// 1. Builds candidate levels from 12 concepts (swing, Fibonacci, harmonic deep
//    retracements, extensions, supply/demand, fair value gaps, previous period
//    H/L/C, floor pivots, Gann Square of 9, round numbers).
// 2. Reaction test on every first touch: wait for a rejection close, then
//    check whether price travelled RR x risk before undoing the reaction.
// 3. Scores each level from its type + context, learned only from EARLIER
//    confirmed reactions on this chart; grades A / B / C by score and records
//    each grade's walk-forward result.
// 4. Random "control" lines go through the same test and give the baseline.
// Historical statistics of this chart only. No buy / sell signals.
// All logic runs on confirmed bars (non-repainting).
// ─────────────────────────────────────────────────────────────────────────────
 
// ───────────── Inputs
string G0 = "Chart"
string showIn    = input.string("A and B", "Grades shown", options = ["A only", "A and B", "All graded"], group = G0, display = display.none)
int    nShow     = input.int(3, "Bands shown each side of price", minval = 1, maxval = 8, group = G0, display = display.none)
float  bandK     = input.float(0.15, "Band half-width (x ATR)", minval = 0.05, step = 0.05, group = G0, display = display.none)
float  mergeK    = input.float(0.5, "Hide a band closer than this to a better one (x ATR)", minval = 0.0, step = 0.1, group = G0, display = display.none)
bool   showMarks = input.bool(true, "Mark past reactions of shown grades (✓ / ✗)", group = G0, display = display.none)
 
string G1 = "Reaction test"
int    pivLen   = input.int(5, "Swing length (bars each side)", minval = 2, group = G1, display = display.none)
int    confBars = input.int(3, "Bars allowed for a rejection close", minval = 1, maxval = 10, group = G1, display = display.none)
float  rr       = input.float(1.0, "Follow-through needed (x risk)", minval = 0.5, step = 0.25, group = G1, display = display.none)
int    maxWait  = input.int(40, "Bars allowed to decide a reaction", minval = 5, group = G1, display = display.none)
float  minDist  = input.float(1.0, "A level must start at least this far from price (x ATR)", minval = 0.25, step = 0.25, group = G1, display = display.none)
int    maxAge   = input.int(400, "Drop untouched levels after (bars)", minval = 50, group = G1, display = display.none)
float  confTol  = input.float(0.25, "Confluence tolerance (x ATR)", minval = 0.05, step = 0.05, group = G1, display = display.none)
float  dispK    = input.float(1.5, "Supply / demand: move bar range (x ATR)", minval = 1.0, step = 0.1, group = G1, display = display.none)
float  stepIn   = input.float(0.0, "Round-number step (0 = auto)", minval = 0.0, group = G1, display = display.none)
 
string G2 = "Grading"
float  pctA      = input.float(20, "Grade A = top % of scores", minval = 5, maxval = 40, group = G2, display = display.none)
float  pctB      = input.float(30, "Grade B = next % of scores", minval = 5, maxval = 50, group = G2, display = display.none)
int    warmN     = input.int(150, "Touches needed before grading starts", minval = 50, group = G2, display = display.none)
float  kShr      = input.float(30, "Caution factor (higher = slower to trust small samples)", minval = 5, group = G2, display = display.none)
int    freshBars = input.int(100, "A level is 'fresh' for (bars)", minval = 10, group = G2, display = display.none)
int    emaFastL  = input.int(50, "Trend: fast EMA", minval = 5, group = G2, display = display.none)
int    emaSlowL  = input.int(200, "Trend: slow EMA", minval = 20, group = G2, display = display.none)
 
string G3 = "Table"
bool   showTable   = input.bool(true, "Show table", group = G3, display = display.none)
bool   showGrades  = input.bool(true, "Section: grade record", group = G3, display = display.none)
bool   showDrivers = input.bool(true, "Section: what helped here (top 3)", group = G3, display = display.none)
bool   showTypes   = input.bool(true, "Section: best level types", group = G3, display = display.none)
bool   showNear    = input.bool(true, "Section: nearest bands", group = G3, display = display.none)
string tblPosIn    = input.string("Top right", "Position", options = ["Top right", "Top left", "Bottom right", "Bottom left"], group = G3, display = display.none)
string tblSzIn     = input.string("Small", "Text size", options = ["Tiny", "Small", "Normal"], group = G3, display = display.none)
 
// ───────────── Colours
color C_SUP   = #2DD4BF
color C_RES   = #FB7185
color C_GOLD  = #FBBF24
color C_PANEL = #0F172A
color C_HEAD  = #1E293B
color C_TEXT  = #E2E8F0
color C_MUTE  = #94A3B8
 
// ───────────── Constants
int F_SR    = 0
int F_F38   = 1
int F_F50   = 2
int F_F61   = 3
int F_HARM  = 4
int F_EXT   = 5
int F_ZONE  = 6
int F_FVG   = 7
int F_PREV  = 8
int F_PIV   = 9
int F_GANN  = 10
int F_ROUND = 11
int F_CTRL  = 12
int NFAM    = 12
int NFEAT   = 6
 
int    minG = showIn == "A only" ? 3 : showIn == "A and B" ? 2 : 1
string tsz  = tblSzIn == "Tiny" ? size.tiny : tblSzIn == "Normal" ? size.normal : size.small
 
string htf     = timeframe.isintraday ? (timeframe.in_seconds() >= 3600 ? "W" : "D") : timeframe.isdaily ? "W" : timeframe.isweekly ? "M" : "12M"
string perName = htf == "D" ? "day" : htf == "W" ? "week" : htf == "M" ? "month" : "year"
string modeTxt = timeframe.isintraday ? "Intraday" : timeframe.isdaily ? "Swing" : "Positional"
 
type Level
    float price
    int   fam
    int   born
    int   side              // +1 = support (price above), -1 = resistance (price below)
    int   state    = 0      // 0 waiting, 1 touched (awaiting rejection close), 3 reaction confirmed, 2 finished
    float atrT     = na
    int   touchBar = na
    float ext      = na
    float entry    = na
    float stop     = na
    float tgt      = na
    int   confBar  = na
    bool  fTrend   = false
    bool  fConf    = false
    bool  fFresh   = false
    bool  fCalm    = false
    bool  fZone    = false
    bool  fGentle  = false
    float score    = na
    int   grade    = 0      // 0 not graded yet, 1 C, 2 B, 3 A
 
var array<Level> lv        = array.new<Level>()
var array<int>   famS      = array.new_int(24, 0)   // fam*2 + (0 followed through, 1 failed)
var array<int>   featS     = array.new_int(24, 0)   // (k*2 + v)*2 + outcome
var array<int>   gS        = array.new_int(8, 0)    // grade*2 + outcome
var array<int>   tot       = array.new_int(2, 0)
var array<int>   ctrl      = array.new_int(2, 0)
var array<float> scoreHist = array.new<float>()
 
// ───────────── Helpers
famName(int f) =>
    switch f
        0  => "Swing"
        1  => "Fib 38.2%"
        2  => "Fib 50%"
        3  => "Fib 61.8%"
        4  => "Harmonic 78.6–88.6%"
        5  => "Fib extension"
        6  => "Supply/demand"
        7  => "Fair value gap"
        8  => "Prev " + perName + " H/L/C"
        9  => "Pivot"
        10 => "Gann Sq9"
        11 => "Round number"
        => "Random"
 
featName(int k) =>
    switch k
        0 => "With trend"
        1 => "Confluence"
        2 => "Fresh level"
        3 => "Calm volatility"
        4 => "Discount / premium side"
        => "Gentle approach"
 
famGroup(int f) =>
    f >= 1 and f <= 5 ? 1 : f
 
gName(int g) =>
    g == 3 ? "A" : g == 2 ? "B" : g == 1 ? "C" : "–"
 
bump(array<int> a, int i) =>
    a.set(i, a.get(i) + 1)
 
clampP(float p) =>
    math.min(0.98, math.max(0.02, p))
 
lg(float p) =>
    float q = clampP(p)
    math.log(q / (1 - q))
 
shr(float h, float n, float base) =>
    (h + kShr * base) / (n + kShr)
 
baseRate() =>
    float n = tot.get(0) + tot.get(1)
    n > 0 ? clampP(tot.get(0) / n) : 0.5
 
famN(int f) =>
    famS.get(f * 2) + famS.get(f * 2 + 1)
 
famPct(int f) =>
    float n = famN(f)
    n > 0 ? 100.0 * famS.get(f * 2) / n : na
 
featPct(int k, bool v) =>
    int   i = (k * 2 + (v ? 1 : 0)) * 2
    float n = featS.get(i) + featS.get(i + 1)
    n > 0 ? 100.0 * featS.get(i) / n : na
 
gradeN(int g) =>
    gS.get(g * 2) + gS.get(g * 2 + 1)
 
gradePct(int g) =>
    float n = gradeN(g)
    n > 0 ? 100.0 * gS.get(g * 2) / n : na
 
featTerm(int k, bool v, float base) =>
    int   i = (k * 2 + (v ? 1 : 0)) * 2
    float n = featS.get(i) + featS.get(i + 1)
    lg(shr(featS.get(i), n, base)) - lg(base)
 
scoreOf(int fam, bool f0, bool f1, bool f2, bool f3, bool f4, bool f5) =>
    float base = baseRate()
    float nf   = famN(fam)
    float s    = lg(shr(famS.get(fam * 2), nf, base))
    s += featTerm(0, f0, base)
    s += featTerm(1, f1, base)
    s += featTerm(2, f2, base)
    s += featTerm(3, f3, base)
    s += featTerm(4, f4, base)
    s += featTerm(5, f5, base)
    100 / (1 + math.exp(-s))
 
gradeOf(float sc) =>
    int g = 0
    if scoreHist.size() >= warmN
        float qA = scoreHist.percentile_linear_interpolation(100 - pctA)
        float qB = scoreHist.percentile_linear_interpolation(100 - pctA - pctB)
        g := sc >= qA ? 3 : sc >= qB ? 2 : 1
    g
 
hasConf(int i, float a) =>
    bool  r = false
    Level l = lv.get(i)
    for j = 0 to lv.size() - 1
        if j != i
            Level o = lv.get(j)
            if (o.state == 0 or o.touchBar == bar_index) and o.fam != F_CTRL and famGroup(o.fam) != famGroup(l.fam) and math.abs(o.price - l.price) <= confTol * a
                r := true
                break
    r
 
zoneOK(int side, float p, float mid) =>
    not na(mid) and (side == 1 ? p < mid : p > mid)
 
// needSide: 1 = only if price is above the level, -1 = only if below, 0 = either
addLevel(array<Level> arr, float p, int f, float a, int needSide) =>
    bool ok = not na(p) and not na(a) and a > 0 and p > 0
    if ok
        ok := math.abs(close - p) >= minDist * a
    if ok and needSide != 0
        ok := needSide == 1 ? close > p : close < p
    if ok and arr.size() > 0
        for i = 0 to arr.size() - 1
            Level l = arr.get(i)
            if l.fam == f and l.state == 0 and math.abs(l.price - p) < 0.05 * a
                ok := false
                break
    if ok
        arr.push(Level.new(price = p, fam = f, born = bar_index, side = close > p ? 1 : -1))
    ok
 
finish(Level l, int res) =>
    l.state := 2
    if res != 0
        int o = res == 1 ? 0 : 1
        if l.fam == F_CTRL
            bump(ctrl, o)
        else
            bump(tot, o)
            bump(famS, l.fam * 2 + o)
            bump(gS, l.grade * 2 + o)
            bump(featS, (0 + (l.fTrend ? 1 : 0)) * 2 + o)
            bump(featS, (2 + (l.fConf ? 1 : 0)) * 2 + o)
            bump(featS, (4 + (l.fFresh ? 1 : 0)) * 2 + o)
            bump(featS, (6 + (l.fCalm ? 1 : 0)) * 2 + o)
            bump(featS, (8 + (l.fZone ? 1 : 0)) * 2 + o)
            bump(featS, (10 + (l.fGentle ? 1 : 0)) * 2 + o)
    if showMarks and l.fam != F_CTRL and res != 0 and l.grade >= minG
        label.new(l.confBar, l.price, res == 1 ? "✓" : "✗", style = label.style_none,
             textcolor = res == 1 ? (l.grade == 3 ? C_GOLD : C_SUP) : C_RES, size = size.normal,
             tooltip = "Grade " + gName(l.grade) + " · " + famName(l.fam) + (res == 1 ? " — reaction followed through" : " — reaction failed"))
    true
 
// ───────────── Series used by the engine (global scope on purpose)
float atr     = ta.atr(14)
float atrAvg  = ta.sma(atr, 100)
float emaF    = ta.ema(close, emaFastL)
float emaS    = ta.ema(close, emaSlowL)
bool  upTr    = emaF > emaS
bool  calmNow = atr <= atrAvg
bool  fastNow = math.abs(close - close[3]) > 1.5 * atr
float ph      = ta.pivothigh(high, pivLen, pivLen)
float pl      = ta.pivotlow(low, pivLen, pivLen)
bool  newPer  = timeframe.change(htf)
float prevC   = close[1]
float h2      = high[2]
float l2      = low[2]
float rU      = math.random(1.0, 3.0, 7)
float rS      = math.random(0.0, 1.0, 11)
 
float rng    = high - low
bool  upDisp = rng > dispK * atr and close > open and close >= high - 0.3 * rng
bool  dnDisp = rng > dispK * atr and close < open and close <= low + 0.3 * rng
bool  fvgUp  = low > h2 and low - h2 > 0.3 * atr
bool  fvgDn  = high < l2 and l2 - high > 0.3 * atr
 
float mag   = math.pow(10, math.floor(math.log10(math.max(close, 0.0001))))
float rStep = stepIn > 0 ? stepIn : mag / 20
 
var float lastHi = na
var float lastLo = na
var float perHi  = na
var float perLo  = na
var float pMid   = na
 
bool touchA = false
bool confA  = false
bool confAB = false
 
// ───────────── Engine
if barstate.isconfirmed and not na(atr) and not na(atrAvg) and not na(emaS)
    // 1. Update existing levels
    if lv.size() > 0
        for i = lv.size() - 1 to 0
            Level l    = lv.get(i)
            bool  real = l.fam != F_CTRL
            if l.state == 0
                bool touched = l.side == 1 ? low <= l.price : high >= l.price
                if touched
                    l.state    := 1
                    l.atrT     := atr
                    l.touchBar := bar_index
                    l.ext      := l.side == 1 ? low : high
                    if real
                        l.fTrend  := (l.side == 1 and upTr) or (l.side == -1 and not upTr)
                        l.fConf   := hasConf(i, atr)
                        l.fFresh  := bar_index - l.born <= freshBars
                        l.fCalm   := calmNow
                        l.fZone   := zoneOK(l.side, l.price, pMid)
                        l.fGentle := not fastNow
                        l.score   := scoreOf(l.fam, l.fTrend, l.fConf, l.fFresh, l.fCalm, l.fZone, l.fGentle)
                        l.grade   := gradeOf(l.score)
                        scoreHist.push(l.score)
                        if scoreHist.size() > 600
                            scoreHist.shift()
                        if l.grade == 3
                            touchA := true
                else if bar_index - l.born > maxAge
                    l.state := 2
            if l.state == 1
                l.ext := l.side == 1 ? math.min(l.ext, low) : math.max(l.ext, high)
                float br   = high - low
                bool  fail = l.side == 1 ? close < l.price - 0.25 * l.atrT : close > l.price + 0.25 * l.atrT
                bool  rej  = l.side == 1 ? (close > l.price + 0.1 * l.atrT and close - low >= 0.5 * br) : (close < l.price - 0.1 * l.atrT and high - close >= 0.5 * br)
                if fail
                    l.state := 2
                else if rej
                    float e  = close
                    float s  = l.ext - l.side * 0.1 * l.atrT
                    float rk = math.max(math.abs(e - s), 0.3 * l.atrT)
                    if rk > 2.0 * l.atrT
                        l.state := 2
                    else
                        l.entry   := e
                        l.stop    := e - l.side * rk
                        l.tgt     := e + l.side * rr * rk
                        l.confBar := bar_index
                        l.state   := 3
                        if real and l.grade == 3
                            confA := true
                        if real and l.grade >= 2
                            confAB := true
                else if bar_index - l.touchBar >= confBars - 1
                    l.state := 2
            else if l.state == 3
                bool hs = l.side == 1 ? low <= l.stop : high >= l.stop
                bool ht = l.side == 1 ? high >= l.tgt : low <= l.tgt
                if hs
                    finish(l, -1)
                else if ht
                    finish(l, 1)
                else if bar_index - l.confBar >= maxWait
                    finish(l, 0)
        for i = lv.size() - 1 to 0
            if lv.get(i).state == 2
                lv.remove(i)
 
    // 2. Create new levels
    if not na(ph)
        addLevel(lv, ph, F_SR, atr, 0)
        if not na(lastLo) and ph > lastLo
            float legU = ph - lastLo
            addLevel(lv, ph - 0.382 * legU, F_F38, atr, 1)
            addLevel(lv, ph - 0.500 * legU, F_F50, atr, 1)
            addLevel(lv, ph - 0.618 * legU, F_F61, atr, 1)
            addLevel(lv, ph - 0.786 * legU, F_HARM, atr, 1)
            addLevel(lv, ph - 0.886 * legU, F_HARM, atr, 1)
            addLevel(lv, ph + 0.272 * legU, F_EXT, atr, -1)
            addLevel(lv, ph + 0.618 * legU, F_EXT, atr, -1)
        lastHi := ph
        addLevel(lv, close + (rS > 0.5 ? 1 : -1) * rU * atr, F_CTRL, atr, 0)
    if not na(pl)
        addLevel(lv, pl, F_SR, atr, 0)
        if not na(lastHi) and pl < lastHi
            float legD = lastHi - pl
            addLevel(lv, pl + 0.382 * legD, F_F38, atr, -1)
            addLevel(lv, pl + 0.500 * legD, F_F50, atr, -1)
            addLevel(lv, pl + 0.618 * legD, F_F61, atr, -1)
            addLevel(lv, pl + 0.786 * legD, F_HARM, atr, -1)
            addLevel(lv, pl + 0.886 * legD, F_HARM, atr, -1)
            addLevel(lv, pl - 0.272 * legD, F_EXT, atr, 1)
            addLevel(lv, pl - 0.618 * legD, F_EXT, atr, 1)
        lastLo := pl
        addLevel(lv, close + (rS > 0.5 ? 1 : -1) * rU * atr, F_CTRL, atr, 0)
 
    if upDisp
        addLevel(lv, open, F_ZONE, atr, 1)
    if dnDisp
        addLevel(lv, open, F_ZONE, atr, -1)
    if fvgUp
        addLevel(lv, (low + h2) / 2, F_FVG, atr, 1)
    if fvgDn
        addLevel(lv, (high + l2) / 2, F_FVG, atr, -1)
 
    if newPer
        if not na(perHi) and not na(perLo)
            float pc = prevC
            float pp = (perHi + perLo + pc) / 3
            addLevel(lv, perHi, F_PREV, atr, 0)
            addLevel(lv, perLo, F_PREV, atr, 0)
            addLevel(lv, pc, F_PREV, atr, 0)
            addLevel(lv, pp, F_PIV, atr, 0)
            addLevel(lv, 2 * pp - perLo, F_PIV, atr, 0)
            addLevel(lv, 2 * pp - perHi, F_PIV, atr, 0)
            addLevel(lv, pp + (perHi - perLo), F_PIV, atr, 0)
            addLevel(lv, pp - (perHi - perLo), F_PIV, atr, 0)
            float sq = math.sqrt(pc)
            addLevel(lv, math.pow(sq + 0.25, 2), F_GANN, atr, 0)
            addLevel(lv, math.pow(sq + 0.50, 2), F_GANN, atr, 0)
            addLevel(lv, math.pow(sq + 1.00, 2), F_GANN, atr, 0)
            addLevel(lv, math.pow(sq - 0.25, 2), F_GANN, atr, 0)
            addLevel(lv, math.pow(sq - 0.50, 2), F_GANN, atr, 0)
            addLevel(lv, math.pow(sq - 1.00, 2), F_GANN, atr, 0)
            pMid := (perHi + perLo) / 2
        perHi := high
        perLo := low
    else
        perHi := na(perHi) ? high : math.max(perHi, high)
        perLo := na(perLo) ? low : math.min(perLo, low)
 
    addLevel(lv, math.ceil(close / rStep) * rStep, F_ROUND, atr, 0)
    addLevel(lv, math.floor(close / rStep) * rStep, F_ROUND, atr, 0)
 
    while lv.size() > 400
        lv.shift()
 
// ───────────── Live map and table
var array<label> dLabels = array.new<label>()
var array<box>   dBoxes  = array.new<box>()
 
tblPos = switch tblPosIn
    "Top left"     => position.top_left
    "Bottom right" => position.bottom_right
    "Bottom left"  => position.bottom_left
    => position.top_right
 
var table tb = table.new(tblPos, 4, 16, bgcolor = color.new(C_PANEL, 5), border_width = 1, border_color = color.new(C_MUTE, 85), frame_width = 1, frame_color = color.new(C_MUTE, 60))
 
cell(int c, int r, string s, color tc, color bg) =>
    table.cell(tb, c, r, s, text_color = tc, bgcolor = bg, text_size = tsz, text_halign = text.align_left)
 
pctTxt(float p) =>
    na(p) ? "–" : str.tostring(p, "0") + "%"
 
drawBand(Level l, int g, float a, float rndP, bool active) =>
    color  base = l.side == 1 ? C_SUP : C_RES
    float  gp   = gradePct(g)
    string role = l.side == 1 ? "support" : "resistance"
    string txt  = (active ? "◆ " : "") + (g == 3 ? "★ A" : gName(g)) + "  " + famName(l.fam) + "  ·  " + pctTxt(gp)
    string tip  = famName(l.fam) + " " + role + " at " + str.tostring(l.price, format.mintick) + "\nGrade " + gName(g) + ": " + pctTxt(gp) + " of " + str.tostring(gradeN(g)) +
         " confirmed reactions followed through on this chart (random lines: " + pctTxt(rndP) + ")" +
         (active ? "\nReaction confirmed. Reaction extreme: " + str.tostring(l.stop, format.mintick) + " · " + str.tostring(rr) + "x reference: " + str.tostring(l.tgt, format.mintick) : "")
    dBoxes.push(box.new(l.born, l.price + bandK * a, bar_index, l.price - bandK * a, border_color = color.new(base, g == 3 ? 40 : 75), border_width = 1,
         bgcolor = color.new(base, active ? 60 : g == 3 ? 72 : g == 2 ? 84 : 92), extend = extend.right))
    dLabels.push(label.new(bar_index + 4, l.price, txt, style = label.style_label_left, color = g == 3 ? color.new(C_GOLD, 5) : color.new(base, 78),
         textcolor = g == 3 ? color.black : base, size = size.small, tooltip = tip))
    true
 
if barstate.islast
    while dLabels.size() > 0
        label.delete(dLabels.pop())
    while dBoxes.size() > 0
        box.delete(dBoxes.pop())
 
    float cN    = ctrl.get(0) + ctrl.get(1)
    float rndP  = cN > 0 ? 100.0 * ctrl.get(0) / cN : na
    bool  ready = scoreHist.size() >= warmN
 
    string nearUp = "none"
    string nearDn = "none"
 
    if ready and lv.size() > 0
        // live confirmed reactions
        for i = 0 to lv.size() - 1
            Level l = lv.get(i)
            if l.state == 3 and l.fam != F_CTRL and l.grade >= minG
                drawBand(l, l.grade, atr, rndP, true)
 
        // waiting levels: nearest candidates each side, best score first, merged
        array<float> dUp = array.new<float>()
        array<int>   iUp = array.new<int>()
        array<float> dDn = array.new<float>()
        array<int>   iDn = array.new<int>()
        for i = 0 to lv.size() - 1
            Level l = lv.get(i)
            if l.state == 0 and l.fam != F_CTRL
                if l.price >= close
                    dUp.push(l.price - close)
                    iUp.push(i)
                else
                    dDn.push(close - l.price)
                    iDn.push(i)
        array<int> oUp = dUp.sort_indices(order.ascending)
        array<int> oDn = dDn.sort_indices(order.ascending)
 
        for sd = 0 to 1
            array<int> ord = sd == 0 ? oUp : oDn
            array<int> idx = sd == 0 ? iUp : iDn
            int cnt = math.min(25, ord.size())
            array<int>   cI = array.new<int>()
            array<float> cS = array.new<float>()
            array<int>   cG = array.new<int>()
            if cnt > 0
                for k = 0 to cnt - 1
                    int   li = idx.get(ord.get(k))
                    Level l  = lv.get(li)
                    bool  tr = (l.side == 1 and upTr) or (l.side == -1 and not upTr)
                    float sc = scoreOf(l.fam, tr, hasConf(li, atr), bar_index - l.born <= freshBars, calmNow, zoneOK(l.side, l.price, pMid), not fastNow)
                    int   g  = gradeOf(sc)
                    if g >= minG
                        cI.push(li)
                        cS.push(sc)
                        cG.push(g)
            array<int>   so     = cS.sort_indices(order.descending)
            array<float> picked = array.new<float>()
            float bestD = na
            if so.size() > 0
                for m = 0 to so.size() - 1
                    if picked.size() < nShow
                        Level l    = lv.get(cI.get(so.get(m)))
                        int   g    = cG.get(so.get(m))
                        bool  near = false
                        if picked.size() > 0
                            for q = 0 to picked.size() - 1
                                if math.abs(picked.get(q) - l.price) < mergeK * atr
                                    near := true
                                    break
                        if not near
                            picked.push(l.price)
                            drawBand(l, g, atr, rndP, false)
                            float d = math.abs(l.price - close)
                            if na(bestD) or d < bestD
                                bestD := d
                                string nr = gName(g) + " · " + str.tostring(l.price, format.mintick) + " · " + famName(l.fam) + " · " + str.tostring(d / atr, "0.0") + " ATR"
                                if sd == 0
                                    nearUp := nr
                                else
                                    nearDn := nr
 
    if showTable
        int r = 0
        cell(0, r, "LEVEL EVIDENCE MAP  ·  " + modeTxt + " mode\nwalk-forward record on this chart", C_GOLD, C_HEAD)
        table.merge_cells(tb, 0, r, 3, r)
        r += 1
        if not ready
            cell(0, r, "Learning this chart: " + str.tostring(scoreHist.size()) + " of " + str.tostring(warmN) + " touches seen.\nLoad more history or use a lower timeframe.", C_TEXT, na)
            table.merge_cells(tb, 0, r, 3, r)
            r += 1
        else
            if showGrades
                cell(0, r, "Grade", C_MUTE, na)
                cell(1, r, "Reactions", C_MUTE, na)
                cell(2, r, "Followed through", C_MUTE, na)
                cell(3, r, "vs random", C_MUTE, na)
                r += 1
                for g = 3 to 1
                    float gp = gradePct(g)
                    float df = gp - rndP
                    color gc = g == 3 ? C_GOLD : g == 2 ? C_TEXT : C_MUTE
                    cell(0, r, g == 3 ? "★ A" : g == 2 ? "B" : "C", gc, na)
                    cell(1, r, str.tostring(gradeN(g)), gc, na)
                    cell(2, r, pctTxt(gp), gc, na)
                    cell(3, r, na(df) ? "–" : str.tostring(df, "+0;-0") + " pts", na(df) ? C_MUTE : df >= 5 ? C_SUP : df <= -5 ? C_RES : C_MUTE, na)
                    r += 1
                cell(0, r, "Random lines", C_MUTE, na)
                cell(1, r, str.tostring(cN, "0"), C_MUTE, na)
                cell(2, r, pctTxt(rndP), C_MUTE, na)
                cell(3, r, "baseline", C_MUTE, na)
                r += 1
 
            if showDrivers
                array<float> gaps = array.new<float>()
                for k = 0 to NFEAT - 1
                    float d = featPct(k, true) - featPct(k, false)
                    gaps.push(na(d) ? 0.0 : math.abs(d))
                array<int> go = gaps.sort_indices(order.descending)
                cell(0, r, "WHAT HELPED HERE", C_GOLD, C_HEAD)
                cell(1, r, "yes", C_MUTE, C_HEAD)
                cell(2, r, "no", C_MUTE, C_HEAD)
                cell(3, r, "gap", C_MUTE, C_HEAD)
                r += 1
                for m = 0 to 2
                    int   k  = go.get(m)
                    float py = featPct(k, true)
                    float pn = featPct(k, false)
                    float d  = py - pn
                    cell(0, r, featName(k), C_TEXT, na)
                    cell(1, r, pctTxt(py), C_TEXT, na)
                    cell(2, r, pctTxt(pn), C_TEXT, na)
                    cell(3, r, na(d) ? "–" : str.tostring(d, "+0;-0") + " pts", na(d) ? C_MUTE : d >= 3 ? C_SUP : d <= -3 ? C_RES : C_MUTE, na)
                    r += 1
 
            if showTypes
                array<float> fp = array.new<float>()
                for f = 0 to NFAM - 1
                    fp.push(famN(f) >= 30 ? famPct(f) : -1.0)
                array<int> fo = fp.sort_indices(order.descending)
                string best = ""
                for m = 0 to 2
                    int f = fo.get(m)
                    if fp.get(f) >= 0
                        best += (best == "" ? "" : "\n") + famName(f) + "  " + pctTxt(fp.get(f)) + "  (" + str.tostring(famN(f)) + ")"
                cell(0, r, "Best level types\n" + (best == "" ? "not enough reactions yet" : best), C_TEXT, na)
                table.merge_cells(tb, 0, r, 3, r)
                r += 1
 
            if showNear
                cell(0, r, "Above:  " + nearUp + "\nBelow:  " + nearDn, C_TEXT, na)
                table.merge_cells(tb, 0, r, 3, r)
                r += 1
        cell(0, r, "Followed through = after a rejection close,\nprice moved " + str.tostring(rr) + "x the risk before undoing it.\nPast behaviour; not a recommendation.", C_MUTE, na)
        table.merge_cells(tb, 0, r, 3, r)
 
// ───────────── Alerts
alertcondition(touchA, "Price touched a Grade A band", "Level Evidence Map: price touched a Grade A band")
alertcondition(confA, "Reaction confirmed at a Grade A band", "Level Evidence Map: reaction confirmed at a Grade A band")
alertcondition(confAB, "Reaction confirmed at a Grade A or B band", "Level Evidence Map: reaction confirmed at a Grade A or B band")

← 返回列表