Uptrick: Volatility Aggregation Model

Uptrick · study · 226 行 · 点赞 2,186 · TradingView 原页

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

Pine Script

// This work is licensed under an Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0) 
// https://creativecommons.org/licenses/by-sa/4.0/
// © Uptrick
//@version=6
 
 
//    ██╗   ██╗██████╗ ████████╗██████╗ ██╗ ██████╗██╗  ██╗
//    ██║   ██║██╔══██╗╚══██╔══╝██╔══██╗██║██╔════╝██║ ██╔╝
//    ██║   ██║██████╔╝   ██║   ██████╔╝██║██║     █████╔╝ 
//    ██║   ██║██╔═══╝    ██║   ██╔══██╗██║██║     ██╔═██╗ 
//    ╚██████╔╝██║        ██║   ██║  ██║██║╚██████╗██║  ██╗
//     ╚═════╝ ╚═╝        ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝
 
indicator("Uptrick: Volatility Aggregation Model", "VAM", overlay=true, max_bars_back=5000, max_labels_count=500)
 
//────────────────────────────────────────────────────────────
// ╭────────── Plot ───────────╮
//────────────────────────────────────────────────────────────
grpBT = "╭────────── Plot ───────────╮"
startDate = input.time(timestamp("2018-01-01 00:00"), "Start Date", group=grpBT)
canTrade  = time >= startDate
 
//────────────────────────────────────────────────────────────
// ╭────────── Ensemble ───────────╮
//────────────────────────────────────────────────────────────
grpE = "╭────────── Ensemble ───────────╮"
scoreBuy   = input.float(0.10, "Buy Threshold", step=0.01, group=grpE)
scoreSell  = input.float(-0.10, "Sell Threshold", step=0.01, group=grpE)
showLabels = input.bool(true, "Show BUY/SELL Labels", group=grpE)
 
//────────────────────────────────────────────────────────────
// ╭────────── Visuals ───────────╮
//────────────────────────────────────────────────────────────
grpV = "╭────────── Visuals ───────────╮"
showFill     = input.bool(true, "Fill Between Trail Layers", group=grpV)
showATRLayer = true
trailSmooth  = input.int(4, "Trail Smooth", minval=1, maxval=50, group=grpV)
atrLen       = input.int(14, "ATR Layer Length", minval=1, maxval=200, group=grpV)
atrLayerMult = input.float(0.90, "ATR Layer Mult", step=0.05, minval=0.0, maxval=5.0, group=grpV)
 
//────────────────────────────────────────────────────────────
// ╭────────── Colors ───────────╮
//────────────────────────────────────────────────────────────
grpC = "╭────────── Colors ───────────╮"
bullC = input.color(#00FFE5, "Bull", group=grpC)
bearC = input.color(#FF00B5, "Bear", group=grpC)
grayC = input.color(color.new(#9AA0A6, 0), "Neutral Gray", group=grpC)
txtC  = #FFFFFF
 
//────────────────────────────────────────────────────────────
// ╭────────── 5 Speeds ───────────╮
// Simplified: Source input only.
//────────────────────────────────────────────────────────────
grpS = "╭────────── 5 Speeds ───────────╮"
src = input.source(close, "Source", group=grpS)
 
// Fixed logic
flipMode = "Breakout"
 
// Fixed presets (fast → slow)
//────────────────────────────────────────────────────────────
// ╭────────── 5 Speeds Inputs ───────────╮
//────────────────────────────────────────────────────────────
 
// Lengths
len1 = input.int(8,  "Speed 1 Length",  minval=1, group=grpS)
len2 = input.int(10, "Speed 2 Length",  minval=1, group=grpS)
len3 = input.int(14, "Speed 3 Length",  minval=1, group=grpS)
len4 = input.int(20, "Speed 4 Length",  minval=1, group=grpS)
len5 = input.int(28, "Speed 5 Length",  minval=1, group=grpS)
 
// Volatility multipliers
mult1 = input.float(1.05, "Speed 1 Vol Mult", step=0.01, group=grpS)
mult2 = input.float(1.10, "Speed 2 Vol Mult", step=0.01, group=grpS)
mult3 = input.float(1.15, "Speed 3 Vol Mult", step=0.01, group=grpS)
mult4 = input.float(1.20, "Speed 4 Vol Mult", step=0.01, group=grpS)
mult5 = input.float(1.25, "Speed 5 Vol Mult", step=0.01, group=grpS)
 
// Band multipliers
band1 = input.float(1.15, "Speed 1 Band Mult", step=0.01, group=grpS)
band2 = input.float(1.20, "Speed 2 Band Mult", step=0.01, group=grpS)
band3 = input.float(1.25, "Speed 3 Band Mult", step=0.01, group=grpS)
band4 = input.float(1.30, "Speed 4 Band Mult", step=0.01, group=grpS)
band5 = input.float(1.35, "Speed 5 Band Mult", step=0.01, group=grpS)
 
// Smoothing
smooth1 = input.int(2, "Speed 1 Smooth", minval=1, maxval=50, group=grpS)
smooth2 = input.int(2, "Speed 2 Smooth", minval=1, maxval=50, group=grpS)
smooth3 = input.int(3, "Speed 3 Smooth", minval=1, maxval=50, group=grpS)
smooth4 = input.int(3, "Speed 4 Smooth", minval=1, maxval=50, group=grpS)
smooth5 = input.int(4, "Speed 5 Smooth", minval=1, maxval=50, group=grpS)
 
 
//────────────────────────────────────────────────────────────
// Helper: r1Snap side engine (Breakout only)
// Returns: [side, upper, lower]
//────────────────────────────────────────────────────────────
f_r1Side(_src, _len, _r1Mult, _bandMult, _smooth) =>
    _tr    = ta.tr(true)
    _r1Raw = ta.ema(_tr, _len) * _r1Mult
    _r1    = ta.ema(_r1Raw, _smooth)
 
    var float _center = na
    if barstate.isfirst
        _center := _src
    else
        _prev = nz(_center[1], _src)
        _diff = _src - _prev
        if _diff > _r1
            _center := _prev + (_diff - _r1)
        else if _diff < -_r1
            _center := _prev + (_diff + _r1)
        else
            _center := _prev
 
    _upperRaw = _center + _r1 * _bandMult
    _lowerRaw = _center - _r1 * _bandMult
 
    _upper = ta.ema(_upperRaw, _smooth)
    _lower = ta.ema(_lowerRaw, _smooth)
 
    _breakLong  = ta.crossover(_src, _upper)
    _breakShort = ta.crossunder(_src, _lower)
 
    var int _side = 1
    if barstate.isfirst
        _side := 1
 
    if _breakLong
        _side := 1
    else if _breakShort
        _side := -1
 
    [_side, _upper, _lower]
 
//────────────────────────────────────────────────────────────
// Compute 5 sides
//────────────────────────────────────────────────────────────
[side1, upper1, lower1] = f_r1Side(src, len1, mult1, band1, smooth1)
[side2, upper2, lower2] = f_r1Side(src, len2, mult2, band2, smooth2)
[side3, upper3, lower3] = f_r1Side(src, len3, mult3, band3, smooth3)
[side4, upper4, lower4] = f_r1Side(src, len4, mult4, band4, smooth4)
[side5, upper5, lower5] = f_r1Side(src, len5, mult5, band5, smooth5)
 
// Score: +1 bull, -1 bear
scoreRaw = (side1 + side2 + side3 + side4 + side5)
score    = scoreRaw / 5.0
 
isBull = score > scoreBuy
isBear = score < scoreSell
isFlat = not isBull and not isBear
 
// Entry signals from score crossing thresholds
buySig  = ta.crossover(score, scoreBuy)
sellSig = ta.crossunder(score, scoreSell)
 
//────────────────────────────────────────────────────────────
// Trail visuals from the "middle" engine (Speed 3) for stability
//────────────────────────────────────────────────────────────
tr = ta.tr(true)
atrLayer = ta.ema(tr, atrLen)
 
trailLower1 = ta.ema(lower3, trailSmooth)
trailUpper1 = ta.ema(upper3, trailSmooth)
 
trailLower2 = ta.ema(trailLower1 - atrLayer * atrLayerMult, trailSmooth)
trailUpper2 = ta.ema(trailUpper1 + atrLayer * atrLayerMult, trailSmooth)
 
lowerAlpha = isBull ? 0 : 100
upperAlpha = isBear ? 0 : 100
 
pTrailLower1 = plot(trailLower1, "Bull Trail", color=color.new(bullC, 100), linewidth=2)
pTrailLower2 = plot(trailLower2, "Bull ATR Layer", color=color.new(bullC, showATRLayer ? lowerAlpha : 100), linewidth=1)
 
pTrailUpper1 = plot(trailUpper1, "Bear Trail", color=color.new(bearC, 100), linewidth=2)
pTrailUpper2 = plot(trailUpper2, "Bear ATR Layer", color=color.new(bearC, showATRLayer ? upperAlpha : 100), linewidth=1)
 
fillBullCol = showFill ? color.new(bullC, 80) : na
fillBearCol = showFill ? color.new(bearC, 80) : na
 
fill(pTrailLower1, pTrailLower2, color=isBull and showFill and showATRLayer ? fillBullCol : na)
fill(pTrailUpper1, pTrailUpper2, color=isBear and showFill and showATRLayer ? fillBearCol : na)
 
//────────────────────────────────────────────────────────────
// Candles: bull / bear / gray (neutral zone included)
//────────────────────────────────────────────────────────────
cCol =
     isBull ? bullC :
     isBear ? bearC :
     grayC
 
plotcandle(open, high, low, close, "Ensemble Candles", color=cCol, wickcolor=cCol, bordercolor=cCol)
 
//────────────────────────────────────────────────────────────
// Entries + Labels
//────────────────────────────────────────────────────────────
if canTrade and showLabels and buySig
    label.new(
         bar_index, low,
         "𝓤𝓹",
         yloc=yloc.belowbar,
         style=label.style_label_up,
         color=bullC,
         textcolor=#000000,
         size=size.normal
     )
 
if canTrade and showLabels and sellSig
    label.new(
         bar_index, high,
         "𝓓𝓸𝔀𝓷",
         yloc=yloc.abovebar,
         style=label.style_label_down,
         color=bearC,
         textcolor=txtC,
         size=size.normal
     )
 
// Alerts
alertcondition(buySig,  "Ensemble Buy",  "Score crossed above Buy threshold")
alertcondition(sellSig, "Ensemble Sell", "Score crossed below Sell threshold")
 
// Optional plot for debugging
plot(score, "Ensemble Score", color=color.new(txtC, 0), linewidth=1, display=display.none)
hline(scoreBuy,  "Buy Thresh",  color=color.new(bullC, 0), linestyle=hline.style_dotted, display=display.none)
hline(scoreSell, "Sell Thresh", color=color.new(bearC, 0), linestyle=hline.style_dotted, display=display.none)

← 返回列表