FC_VolumeEngine

codename_trading · library · 366 行 · 点赞 0 · TradingView 原页

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

Pine Script

//@version=6
// ═══════════════════════════════════════════════════════════════════════════
//  FC_VolumeEngine — shared fine price-grid volume engine
//  Used by: PVP Pro (v1.2+)
// ───────────────────────────────────────────────────────────────────────────
//  VERSION LOG
//  v1  2026-10-05  Extracted from PVP Pro v1.1: adaptive grid accumulate /
//                  coarsen, TPO bar-visit counts, rows + POC + VA (single /
//                  two-row, midpoint tie-break), composite merge, HVN/LVN,
//                  row smoothing
// ═══════════════════════════════════════════════════════════════════════════
// @description Adaptive fine price-grid volume engine: accumulate buy/sell volume, then build volume-profile rows, POC, value area, composites and volume nodes.
library("FC_VolumeEngine", overlay = true)
 
// @type Engine configuration
// @field useTick  Size rows in ticks instead of a fixed row count
// @field tickRow  Ticks per row when useTick is true
// @field rows     Row count when useTick is false
// @field vaPct    Value-area volume percent
// @field pocMid   Break POC ties toward the range midpoint
// @field twoRow   Use two-row (CBOT) value-area expansion
// @field maxG     Max fine-grid buckets before coarsening
// @field maxRows  Max rows in tick mode
// @field tick     Symbol min tick
export type Cfg
    bool  useTick = false
    int   tickRow = 4
    int   rows    = 50
    float vaPct   = 70.0
    bool  pocMid  = true
    bool  twoRow  = false
    int   maxG    = 2000
    int   maxRows = 250
    float tick    = 0.01
 
// @type Accumulating period state (fine grid)
export type PState
    int          startBar = na
    float        o        = na
    float        h        = na
    float        l        = na
    float        c        = na
    bool         isAH     = false
    float        base     = na
    float        gsz      = na
    array<float> gv
    array<float> gu
    array<float> gc
    float        tv       = 0.0
    float        tb       = 0.0
    int          nBars    = 0
    int          fpBars   = 0
 
// @type Computed profile
export type PResult
    array<float> rv
    array<float> ru
    array<float> rc
    float        rowLow
    float        rowH
    int          n
    int          poc
    int          vaLo
    int          vaHi
    float        pocPx
    float        vahPx
    float        valPx
    float        tv
    float        tb
 
f_rt(float x, float t) =>
    math.round(x / t) * t
 
// @function Centered moving average across profile rows
// @param a    Row values
// @param len  Window length
// @returns    Smoothed copy
export smooth(array<float> a, int len) =>
    int n = a.size()
    array<float> out = array.new<float>(n, 0.0)
    int half = int(len / 2)
    if n > 0
        for i = 0 to n - 1
            float sm  = 0.0
            int   cnt = 0
            for k = math.max(0, i - half) to math.min(n - 1, i + half)
                sm  += a.get(k)
                cnt += 1
            out.set(i, sm / cnt)
    out
 
// @function Fine-grid bucket size for a new period
// @param c    Config
// @param est  Expected period range (e.g. previous period's range)
// @returns    Bucket size in price
export gridSize(Cfg c, float est) =>
    c.useTick ? c.tickRow * c.tick : math.max(1, math.floor(est / (c.rows * 4) / c.tick)) * c.tick
 
// @function New empty state
// @returns PState with empty arrays
export newState() =>
    PState.new(gv = array.new<float>(), gu = array.new<float>(), gc = array.new<float>())
 
// @function Append one empty bucket
export method gpush(PState s) =>
    s.gv.push(0.0)
    s.gu.push(0.0)
    s.gc.push(0.0)
    s
 
// @function Halve grid resolution (merge bucket pairs)
export method coarsen(PState s) =>
    int n = s.gv.size()
    if n > 0
        int m = int(math.ceil(n / 2.0))
        array<float> nv = array.new<float>(m, 0.0)
        array<float> nu = array.new<float>(m, 0.0)
        array<float> nc = array.new<float>(m, 0.0)
        for i = 0 to n - 1
            int j = int(i / 2)
            nv.set(j, nv.get(j) + s.gv.get(i))
            nu.set(j, nu.get(j) + s.gu.get(i))
            nc.set(j, math.max(nc.get(j), s.gc.get(i)))
        s.gv := nv
        s.gu := nu
        s.gc := nc
    s.gsz := s.gsz * 2
    s
 
// @function Spread volume uniformly over a price range
// @param a     Range bound
// @param b     Range bound
// @param v     Total volume
// @param vb    Buy volume
// @param maxG  Max buckets
export method addVol(PState s, float a, float b, float v, float vb, int maxG) =>
    if v > 0 and not na(a) and not na(b)
        float lo = math.min(a, b)
        float hi = math.max(a, b)
        if na(s.base)
            s.base := math.floor(lo / s.gsz) * s.gsz
        while (s.base - lo) / s.gsz > maxG or (hi - s.base) / s.gsz > maxG * 2
            s.coarsen()
        int iLo = int(math.floor((lo - s.base) / s.gsz + 1e-9))
        if iLo < 0
            int addN = -iLo
            for k = 1 to addN
                s.gv.unshift(0.0)
                s.gu.unshift(0.0)
                s.gc.unshift(0.0)
            s.base := s.base - addN * s.gsz
            iLo := 0
        int iHi = math.max(iLo, int(math.floor((hi - s.base) / s.gsz + 1e-9)))
        while iHi >= s.gv.size()
            s.gpush()
        int   cnt  = iHi - iLo + 1
        float per  = v / cnt
        float perB = nz(vb) / cnt
        for i = iLo to iHi
            s.gv.set(i, s.gv.get(i) + per)
            s.gu.set(i, s.gu.get(i) + perB)
        s.tv := s.tv + v
        s.tb := s.tb + nz(vb)
        while s.gv.size() > maxG
            s.coarsen()
    s
 
// @function Count one bar visit across a price range (TPO-style)
export method markBar(PState s, float lo, float hi) =>
    int G = s.gv.size()
    if G > 0 and not na(s.base)
        int iLo = math.max(0, int(math.floor((lo - s.base) / s.gsz + 1e-9)))
        int iHi = math.min(G - 1, int(math.floor((hi - s.base) / s.gsz + 1e-9)))
        if iHi >= iLo
            for i = iLo to iHi
                s.gc.set(i, s.gc.get(i) + 1)
    s
 
// @function Start a new period
export method reset(PState s, int bar, float op, float hp, float lp, float cp, bool ah, float gsz) =>
    s.startBar := bar
    s.o        := op
    s.h        := hp
    s.l        := lp
    s.c        := cp
    s.isAH     := ah
    s.base     := na
    s.gsz      := gsz
    s.gv       := array.new<float>()
    s.gu       := array.new<float>()
    s.gc       := array.new<float>()
    s.tv       := 0.0
    s.tb       := 0.0
    s.nBars    := 0
    s.fpBars   := 0
    s
 
// @function Build rows, POC and value area
// @param s      Period state
// @param cfg    Config
// @param nRows  Row count (ignored in tick mode)
// @returns      PResult or na
export compute(PState s, Cfg cfg, int nRows) =>
    PResult res = na
    int G = s.gv.size()
    if G > 0 and s.tv > 0
        float rowH   = 0.0
        float rowLow = 0.0
        int   n      = 1
        if cfg.useTick
            rowH := cfg.tickRow * cfg.tick
            if rowH < s.gsz
                rowH := math.ceil(s.gsz / rowH - 1e-9) * rowH
            int k0 = int(math.ceil((s.h - s.l) / (rowH * cfg.maxRows)))
            if k0 > 1
                rowH := rowH * k0
            rowLow := math.floor(s.l / rowH) * rowH
            n      := math.max(1, int(math.floor((s.h - rowLow) / rowH + 1e-9)) + 1)
        else
            n      := nRows
            rowLow := s.l
            rowH   := (s.h - s.l) / nRows
        if rowH <= 0
            n      := 1
            rowH   := s.gsz
            rowLow := s.l - s.gsz * 0.5
        array<float> rv = array.new<float>(n, 0.0)
        array<float> ru = array.new<float>(n, 0.0)
        array<float> rc = array.new<float>(n, 0.0)
        for j = 0 to G - 1
            float vj = s.gv.get(j)
            float cj = s.gc.get(j)
            if vj > 0 or cj > 0
                float uj  = s.gu.get(j)
                float bLo = s.base + j * s.gsz
                float bHi = bLo + s.gsz
                int   rA  = math.max(0, math.min(n - 1, int(math.floor((bLo - rowLow) / rowH))))
                int   rB  = math.max(0, math.min(n - 1, int(math.floor((bHi - rowLow) / rowH - 1e-9))))
                for ri = rA to rB
                    rc.set(ri, math.max(rc.get(ri), cj))
                if vj > 0
                    if rA == rB
                        rv.set(rA, rv.get(rA) + vj)
                        ru.set(rA, ru.get(rA) + uj)
                    else
                        float fs = 0.0
                        for ri = rA to rB
                            float f = math.max(0.0, math.min(bHi, rowLow + (ri + 1) * rowH) - math.max(bLo, rowLow + ri * rowH)) / s.gsz
                            fs += f
                            rv.set(ri, rv.get(ri) + vj * f)
                            ru.set(ri, ru.get(ri) + uj * f)
                        float rem = 1.0 - fs
                        if rem > 1e-9
                            int re = bLo < rowLow ? rA : rB
                            rv.set(re, rv.get(re) + vj * rem)
                            ru.set(re, ru.get(re) + uj * rem)
        float tot = rv.sum()
        float mxv = rv.max()
        int   poc = rv.indexof(mxv)
        if cfg.pocMid
            float mid   = (n - 1) / 2.0
            float bestD = math.abs(poc - mid)
            for i = 0 to n - 1
                if rv.get(i) >= mxv * (1 - 1e-9) and math.abs(i - mid) < bestD
                    bestD := math.abs(i - mid)
                    poc   := i
        float tgt = tot * cfg.vaPct / 100.0
        float acc = rv.get(poc)
        int   lo2 = poc
        int   hi2 = poc
        while acc < tgt and (lo2 > 0 or hi2 < n - 1)
            int   stepU = math.min(cfg.twoRow ? 2 : 1, n - 1 - hi2)
            int   stepD = math.min(cfg.twoRow ? 2 : 1, lo2)
            float vU    = -1.0
            float vD    = -1.0
            if stepU > 0
                vU := 0.0
                for k = 1 to stepU
                    vU += rv.get(hi2 + k)
            if stepD > 0
                vD := 0.0
                for k = 1 to stepD
                    vD += rv.get(lo2 - k)
            if vU >= vD
                hi2 += stepU
                acc += vU
            else
                lo2 -= stepD
                acc += vD
        float pPx = cfg.useTick ? rowLow + poc * rowH + (rowH - cfg.tick) * 0.5 : rowLow + (poc + 0.5) * rowH
        res := PResult.new(rv = rv, ru = ru, rc = rc, rowLow = rowLow, rowH = rowH, n = n, poc = poc, vaLo = lo2, vaHi = hi2, pocPx = f_rt(pPx, cfg.tick), vahPx = f_rt(rowLow + (hi2 + 1) * rowH, cfg.tick), valPx = f_rt(rowLow + lo2 * rowH, cfg.tick), tv = tot, tb = s.tb)
    res
 
// @function Merge period snapshots + current period into one composite state
// @param snaps  Completed-period snapshots
// @param cur    Current period
// @param maxG   Max buckets
// @returns      Merged PState
export merge(array<PState> snaps, PState cur, int maxG) =>
    float gsz = cur.gsz
    float lo  = cur.l
    float hi  = cur.h
    int   sb  = cur.startBar
    for s in snaps
        gsz := math.max(gsz, s.gsz)
        lo  := math.min(lo, s.l)
        hi  := math.max(hi, s.h)
        sb  := math.min(sb, s.startBar)
    while (hi - lo) / gsz > maxG
        gsz *= 2
    float base = math.floor(lo / gsz) * gsz
    int   G    = int(math.floor((hi - base) / gsz)) + 2
    PState m = PState.new(startBar = sb, h = hi, l = lo, c = cur.c, base = base, gsz = gsz, gv = array.new<float>(G, 0.0), gu = array.new<float>(G, 0.0), gc = array.new<float>(G, 0.0))
    array<PState> all = snaps.copy()
    all.push(cur)
    for s in all
        int sg = s.gv.size()
        if sg > 0 and not na(s.base)
            for j = 0 to sg - 1
                float v = s.gv.get(j)
                if v > 0
                    float cp = s.base + (j + 0.5) * s.gsz
                    int   k  = math.max(0, math.min(G - 1, int(math.floor((cp - base) / gsz))))
                    m.gv.set(k, m.gv.get(k) + v)
                    m.gu.set(k, m.gu.get(k) + s.gu.get(j))
        m.tv := m.tv + s.tv
        m.tb := m.tb + s.tb
    m
 
// @function HVN / LVN row indices
// @returns [hvn rows, lvn rows]
export nodes(PResult r, int win, float hvnPct, float lvnPct, int maxN, bool wantH, bool wantL) =>
    array<int> hv = array.new<int>()
    array<int> lw = array.new<int>()
    int n = r.n
    if n > 2 * win + 2
        array<float> sm = smooth(r.rv, 3)
        float mx = sm.max()
        for i = win to n - 1 - win
            float v     = sm.get(i)
            bool  isMax = true
            bool  isMin = true
            for j = i - win to i + win
                if j != i
                    float w = sm.get(j)
                    if (j < i and w >= v) or (j > i and w > v)
                        isMax := false
                    if (j < i and w <= v) or (j > i and w < v)
                        isMin := false
            if isMax and wantH and v >= mx * hvnPct / 100.0 and math.abs(i - r.poc) > win
                hv.push(i)
            if isMin and wantL and v <= mx * lvnPct / 100.0
                lw.push(i)
        while hv.size() > maxN
            int wi = 0
            for q = 1 to hv.size() - 1
                if sm.get(hv.get(q)) < sm.get(hv.get(wi))
                    wi := q
            hv.remove(wi)
        while lw.size() > maxN
            int wi = 0
            for q = 1 to lw.size() - 1
                if sm.get(lw.get(q)) > sm.get(lw.get(wi))
                    wi := q
            lw.remove(wi)
    [hv, lw]

← 返回列表