サポートとレジスタンスの突破戦略とトレンドADXフィルターの定量取引システム

/*backtest
start: 2024-05-30 00:00:00
end: 2025-05-29 00:00:00
period: 3d
basePeriod: 3d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

//@version=6
strategy("S/R Breakout Strategy (1H) with Trend and ADX Filter", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// ─────────────────────────────────────────────────────────────
// INPUTS
// ─────────────────────────────────────────────────────────────
pivotLen        = input.int(5, title="Pivot Length")
lookbackBars    = input.int(300, title="Lookback Bars")
maxZoneWidthPct = input.float(2.0, title="Max Zone Width %")
tpLong          = input.float(0.15, title="Take Profit % (Long)")
slLong          = input.float(0.10, title="Stop Loss % (Long)")
tpShort         = input.float(0.10, title="Take Profit % (Short)")
slShort         = input.float(0.10, title="Stop Loss % (Short)")
allowLong       = input.bool(true, title="Allow Long Trades")
allowShort      = input.bool(true, title="Allow Short Trades")

// ADX settings
adxThreshold    = input.float(25.0, title="ADX Threshold")
adxLen          = input.int(14, title="ADX Length")

// Trend filter: 50-period moving average
ma50 = ta.sma(close, 50)

// ─────────────────────────────────────────────────────────────
// CUSTOM ADX FUNCTION
// ─────────────────────────────────────────────────────────────
// This function calculates ADX using the common method based on true range,
// directional movement and smoothing it with the RMA.
f_adx(len) =>
    // true range for the current bar
    tr = ta.tr
    // Calculate upward and downward moves
    upMove   = high - high[1]
    downMove = low[1] - low
    // Determine directional movements
    plusDM  = (upMove > downMove and upMove > 0) ? upMove : 0.0
    minusDM = (downMove > upMove and downMove > 0) ? downMove : 0.0
    // Smooth the values using RMA (running moving average)
    smPlusDM  = ta.rma(plusDM, len)
    smMinusDM = ta.rma(minusDM, len)
    smTR      = ta.rma(tr, len)
    // Calculate the directional indicators, avoid division by zero
    plusDI  = (smTR != 0) ? 100 * smPlusDM / smTR : 0.0
    minusDI = (smTR != 0) ? 100 * smMinusDM / smTR : 0.0
    diSum   = plusDI + minusDI
    dx      = (diSum != 0) ? 100 * math.abs(plusDI - minusDI) / diSum : 0.0
    // Smooth the DX to get ADX
    ta.rma(dx, len)

// Compute ADX value using the custom function
adxValue = f_adx(adxLen)

// ─────────────────────────────────────────────────────────────
// PIVOT DETECTION & SUPPORT/RESISTANCE LEVELS
// ─────────────────────────────────────────────────────────────
pivotHigh = ta.pivothigh(high, pivotLen, pivotLen)
pivotLow  = ta.pivotlow(low, pivotLen, pivotLen)

// Declare arrays for support and resistance levels
var float[] supportLevels    = array.new_float()
var float[] resistanceLevels = array.new_float()

// Function to add a level into the provided array if it meets the criteria.
// Always returns a float (0.0) for consistency.
f_add_level(arr, newLevel) =>
    if array.size(arr) == 0
        array.push(arr, newLevel)
    else
        shouldAdd = true
        for i = 0 to (array.size(arr) - 1)
            existing = array.get(arr, i)
            if math.abs(existing - newLevel) / newLevel * 100 <= maxZoneWidthPct
                shouldAdd := false
        if shouldAdd
            array.push(arr, newLevel)
            if array.size(arr) > 5
                array.shift(arr)
    0.0

// Update support and resistance arrays once sufficient bars have formed
if bar_index > pivotLen * 2
    if not na(pivotLow)
        f_add_level(supportLevels, pivotLow)
    if not na(pivotHigh)
        f_add_level(resistanceLevels, pivotHigh)

// ─────────────────────────────────────────────────────────────
// TRADE MANAGEMENT VARIABLES
// ─────────────────────────────────────────────────────────────
var bool   inTrade    = false
var bool   isLong     = false
var float  entryPrice = na

// Signal flags
longSignal  = false
shortSignal = false

// Detect long signal: price crosses above support level
if array.size(supportLevels) > 0
    for i = 0 to (array.size(supportLevels) - 1)
        lvl = array.get(supportLevels, i)
        if low < lvl and close > lvl
            longSignal := true

// Detect short signal: price crosses below resistance level
if array.size(resistanceLevels) > 0
    for i = 0 to (array.size(resistanceLevels) - 1)
        lvl = array.get(resistanceLevels, i)
        if high > lvl and close < lvl
            shortSignal := true

// ─────────────────────────────────────────────────────────────
// ENTRY CONDITIONS & EXECUTION
// ─────────────────────────────────────────────────────────────
if not inTrade
    // Long entry: require long signal, price above 50MA, and ADX above threshold
    if allowLong and longSignal and close > ma50 and adxValue > adxThreshold
        strategy.entry("Long", strategy.long)
        label.new(x=bar_index, y=low, text="LONG", xloc=xloc.bar_index, style=label.style_label_up, color=color.green, textcolor=color.white)
        entryPrice := close
        isLong     := true
        inTrade    := true
    // Short entry: require short signal, price below 50MA, and ADX above threshold
    else if allowShort and shortSignal and close < ma50 and adxValue > adxThreshold
        strategy.entry("Short", strategy.short)
        label.new(x=bar_index, y=high, text="SHORT", xloc=xloc.bar_index, style=label.style_label_down, color=color.red, textcolor=color.white)
        entryPrice := close
        isLong     := false
        inTrade    := true

// ─────────────────────────────────────────────────────────────
// EXIT CONDITIONS
// ─────────────────────────────────────────────────────────────
if inTrade
    ret = isLong ? (close - entryPrice) / entryPrice : (entryPrice - close) / entryPrice
    tp  = isLong ? tpLong : tpShort
    sl  = isLong ? slLong : slShort
    if ret >= tp or ret <= -sl
        strategy.close_all()
        label.new(x=bar_index, y=close, text="EXIT", xloc=xloc.bar_index, style=label.style_label_left, color=color.orange, textcolor=color.black)
        inTrade    := false
        entryPrice := na

// ─────────────────────────────────────────────────────────────
// ALERT CONDITIONS
// ─────────────────────────────────────────────────────────────
alertcondition(longSignal and allowLong, title="Long Breakout", message="🚀 Long breakout on {{ticker}} at {{close}}")
alertcondition(shortSignal and allowShort, title="Short Breakout", message="🔻 Short breakout on {{ticker}} at {{close}}")