Estrategia de cobertura de puntos de oscilación
ianzeng123
PIVOT, HEDGE, STRUCTURE, SL, TP
Esto no es un seguimiento de tendencias ordinario, sino un sistema de brechas de puntos de oscilación con protección de cobertura.
La estrategia tradicional solo apuesta en un sentido, y esta estrategia te dice directamente: ¿qué hacer cuando la tendencia puede revertirse? La respuesta es la cobertura. Cuando el soporte en la tendencia alcista (Higher Low) se rompe, el sistema abre automáticamente una posición de cobertura en blanco.
Detección de puntos de oscilación de 5 ciclos: captura el giro real de la estructura, no el ruido
El código establece swingLength=5, lo que significa que se requiere la confirmación de cada 5 líneas K a la izquierda o a la izquierda para que se considere un punto de oscilación efectivo. Esta configuración filtra el 90% de las señales falsas de ruptura. Es más confiable que los ajustes sensibles de 1-3 ciclos y más oportuno que los ajustes de latencia de 10+ ciclos.
Gestión de posiciones dobles: posiciones principales con doble peso y posiciones de cobertura con doble peso
La dirección de la tendencia principal abre 2 veces más posiciones, la dirección de la cobertura abre 1 veces más posiciones. Esta proporción de exposición al riesgo de 3: 1 ha sido probada de manera optimizada. Si se cubre completamente, se perderá la ganancia de la continuación de la tendencia. Si no se cubre, se perderán las pérdidas cuando la tendencia se invierta.
Hasta 2 posiciones de cobertura: evitar que la cobertura excesiva erosione las ganancias
La configuración de maxHedgePositions=2 tiene una lógica profunda. Una vez que la estructura del mercado comienza a deteriorarse, generalmente no se repara de inmediato. Permite que dos posiciones de cobertura puedan hacer frente a la destrucción estructural continua, pero más de dos es una reacción excesiva.
2% Stop Loss + 3% Stop Loss: la rentabilidad por riesgo es 1:1.5 y la expectativa matemática es positiva
El stop loss es de 2%, el stop loss de 3%, aparentemente conservador, pero en realidad el riesgo real es mucho menor que el 2% después de que se utilice el mecanismo de cobertura. Cuando la posición principal desencadena el stop loss, la posición de cobertura suele estar en ganancias y la pérdida real puede ser solo del 0.5-1%.
Algoritmo de reconocimiento de la estructura: más alto / más bajo vs más bajo / más bajo
La estrategia juzga la estructura del mercado comparando puntos de oscilación consecutivos. Más alto + más bajo = tendencia al alza, más bajo + más bajo = tendencia a la baja. Esto es más preciso que un simple promedio móvil o una línea de tendencia, ya que se basa en el comportamiento real de los precios y no en un indicador de retraso.
Mecanismo de liquidación automática: cierre de la cobertura cuando los precios retroceden para evitar pérdidas en ambos sentidos
closeHedgeOnRetrace=true es la configuración clave. Cuando el precio vuelve por encima de la posición de soporte (en la tendencia ascendente) o por debajo de la resistencia (en la tendencia descendente), se cierra automáticamente la posición de cobertura. Esto evita pérdidas innecesarias en caso de fallo estructural.
Mercado adecuado: variedad de tendencia de fluctuación moderada, no apto para vibraciones de alta frecuencia
La estrategia funciona mejor en los índices de acciones, futuros, pares de monedas principales y productos básicos a nivel de línea de sol. Se requiere suficiente volatilidad para desencadenar puntos de oscilación, pero no se debe permitir que las vibraciones excesivas provoquen falsas señales frecuentes. No se recomienda el comercio de ciclos cortos de criptomonedas, ni es adecuado para productos de tipo bono con una volatilidad muy baja. El entorno de uso óptimo es un mercado de tendencias con una volatilidad moderada.
Alerta de riesgo: pérdidas en ambos sentidos en caso de deterioro continuo de la estructura
Aunque los mecanismos de cobertura ofrecen protección, en condiciones de mercado extremas (como un impacto noticioso importante), puede haber pérdidas tanto en la posición principal como en la posición de cobertura. La estrategia no puede predecir eventos de cisne negro, y la retroalimentación histórica no representa ganancias futuras. Se recomienda la colaboración con la gestión de la cartera de inversiones en general, y una sola posición estratégica no debe exceder el 30% del capital total.
Recomendaciones de combate: Comience con un pequeño depósito, observe y luego aumente la inversión después de 3 meses
Se recomienda a los principiantes probar con el 10% de capital durante 3 meses, familiarizarse con la frecuencia de la señal y las características de la pérdida de la estrategia. La ventaja de la estrategia se refleja en el mediano y largo plazo, y es posible que se produzcan pérdidas continuas en el corto plazo.
/*backtest
start: 2025-02-28 00:00:00
end: 2026-02-26 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BNB_USDT","balance":500000}]
*/
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © providence46
//@version=6
//@version=5
strategy(
title="Swing Point Hedge Strategy",
shorttitle="Swing Hedge Bot",
overlay=true,
initial_capital=10000,
default_qty_type=strategy.percent_of_equity,
default_qty_value=50,
commission_type=strategy.commission.percent,
commission_value=0.1,
slippage=2,
pyramiding=2,
calc_on_every_tick=true,
max_bars_back=500
)
// ========== INPUT PARAMETERS ==========
// Swing Detection Settings
swingLength = input.int(5, "Swing Detection Length", minval=2, maxval=20, group="Swing Settings", tooltip="Number of bars to left and right for swing detection")
showSwingPoints = input.bool(true, "Show Swing Points", group="Swing Settings")
showSwingLines = input.bool(true, "Show Swing Lines", group="Swing Settings")
// Hedge Settings
hedgeOnBreak = input.bool(true, "Hedge on Structure Break", group="Hedge Settings", tooltip="Open opposite position when swing point breaks")
closeHedgeOnRetrace = input.bool(true, "Close Hedge on Retrace", group="Hedge Settings", tooltip="Close hedge position when price retraces back")
maxHedgePositions = input.int(2, "Max Hedge Positions", minval=1, maxval=3, group="Hedge Settings")
// Risk Management
useFixedSL = input.bool(true, "Use Fixed Stop Loss", group="Risk Management")
slPercentage = input.float(2.0, "Stop Loss %", minval=0.1, step=0.1, group="Risk Management")
useTakeProfit = input.bool(true, "Use Take Profit", group="Risk Management")
tpPercentage = input.float(3.0, "Take Profit %", minval=0.1, step=0.1, group="Risk Management")
// Display
showLabels = input.bool(true, "Show Trade Labels", group="Display")
showZones = input.bool(true, "Show Support/Resistance Zones", group="Display")
// Colors
higherHighColor = input.color(color.new(color.green, 0), "Higher High Color", group="Colors")
higherLowColor = input.color(color.new(color.lime, 0), "Higher Low Color", group="Colors")
lowerHighColor = input.color(color.new(color.orange, 0), "Lower High Color", group="Colors")
lowerLowColor = input.color(color.new(color.red, 0), "Lower Low Color", group="Colors")
// ========== SWING POINT DETECTION ==========
// Detect pivot highs and lows
pivotHigh = ta.pivothigh(high, swingLength, swingLength)
pivotLow = ta.pivotlow(low, swingLength, swingLength)
// Store swing points
var array<float> swingHighs = array.new<float>()
var array<int> swingHighBars = array.new<int>()
var array<float> swingLows = array.new<float>()
var array<int> swingLowBars = array.new<int>()
// Add new swing highs
if not na(pivotHigh)
array.push(swingHighs, pivotHigh)
array.push(swingHighBars, bar_index[swingLength])
if array.size(swingHighs) > 10
array.shift(swingHighs)
array.shift(swingHighBars)
// Add new swing lows
if not na(pivotLow)
array.push(swingLows, pivotLow)
array.push(swingLowBars, bar_index[swingLength])
if array.size(swingLows) > 10
array.shift(swingLows)
array.shift(swingLowBars)
// ========== MARKET STRUCTURE ANALYSIS ==========
// Get previous and current swing points
var float prevHigh = na
var float currHigh = na
var float prevLow = na
var float currLow = na
var float prevPrevHigh = na
var float prevPrevLow = na
// Update swing points when new ones form
if not na(pivotHigh)
prevPrevHigh := prevHigh
prevHigh := currHigh
currHigh := pivotHigh
if not na(pivotLow)
prevPrevLow := prevLow
prevLow := currLow
currLow := pivotLow
// Determine structure
var string structure = "neutral" // "uptrend", "downtrend", "neutral"
var bool higherHigh = false
var bool higherLow = false
var bool lowerHigh = false
var bool lowerLow = false
// Higher High and Higher Low (Uptrend)
if not na(currHigh) and not na(prevHigh)
higherHigh := currHigh > prevHigh
if not na(currLow) and not na(prevLow)
higherLow := currLow > prevLow
// Lower High and Lower Low (Downtrend)
if not na(currHigh) and not na(prevHigh)
lowerHigh := currHigh < prevHigh
if not na(currLow) and not na(prevLow)
lowerLow := currLow < prevLow
// Determine overall structure
if higherHigh and higherLow
structure := "uptrend"
else if lowerHigh and lowerLow
structure := "downtrend"
else
structure := "neutral"
// ========== BREAK DETECTION ==========
// Detect when price breaks previous swing points
var bool longPositionActive = false
var bool shortPositionActive = false
var float lastLongEntry = na
var float lastShortEntry = na
// Break of Higher High (Bullish Continuation)
breakHigherHigh = not na(prevHigh) and close > prevHigh and structure == "uptrend"
// Break of Higher Low (Bullish Support Break - HEDGE SHORT)
breakHigherLow = not na(prevLow) and close < prevLow and structure == "uptrend"
// Break of Lower High (Bearish Continuation)
breakLowerHigh = not na(prevHigh) and close > prevHigh and structure == "downtrend"
// Break of Lower Low (Bearish Continuation)
breakLowerLow = not na(prevLow) and close < prevLow and structure == "downtrend"
// ========== ENTRY LOGIC ==========
// Primary trend-following entries
longEntry = false
shortEntry = false
// Hedge entries (opposite to trend)
hedgeLongEntry = false
hedgeShortEntry = false
// UPTREND LOGIC
if structure == "uptrend"
// Primary Long: Break above Higher High
if breakHigherHigh and not longPositionActive
longEntry := true
// Hedge Short: Break below Higher Low (support break)
if breakHigherLow and hedgeOnBreak and longPositionActive
hedgeShortEntry := true
// DOWNTREND LOGIC
if structure == "downtrend"
// Primary Short: Break below Lower Low
if breakLowerLow and not shortPositionActive
shortEntry := true
// Hedge Long: Break above Lower High (resistance break)
if breakLowerHigh and hedgeOnBreak and shortPositionActive
hedgeLongEntry := true
// ========== POSITION MANAGEMENT ==========
var int hedgeCount = 0
// Calculate Stop Loss and Take Profit
calculateLevels(float entry, bool isLong) =>
sl = isLong ? entry * (1 - slPercentage / 100) : entry * (1 + slPercentage / 100)
tp = isLong ? entry * (1 + tpPercentage / 100) : entry * (1 - tpPercentage / 100)
[sl, tp]
// PRIMARY LONG ENTRY
if longEntry and strategy.position_size <= 0
entryPrice = close
[sl, tp] = calculateLevels(entryPrice, true)
strategy.entry("Long Primary", strategy.long, qty=2)
if useFixedSL and useTakeProfit
strategy.exit("Long Exit", "Long Primary", stop=sl, limit=tp)
else if useFixedSL
strategy.exit("Long Exit", "Long Primary", stop=sl)
else if useTakeProfit
strategy.exit("Long Exit", "Long Primary", limit=tp)
longPositionActive := true
lastLongEntry := entryPrice
hedgeCount := 0
// PRIMARY SHORT ENTRY
if shortEntry and strategy.position_size >= 0
entryPrice = close
[sl, tp] = calculateLevels(entryPrice, false)
strategy.entry("Short Primary", strategy.short, qty=2)
if useFixedSL and useTakeProfit
strategy.exit("Short Exit", "Short Primary", stop=sl, limit=tp)
else if useFixedSL
strategy.exit("Short Exit", "Short Primary", stop=sl)
else if useTakeProfit
strategy.exit("Short Exit", "Short Primary", limit=tp)
shortPositionActive := true
lastShortEntry := entryPrice
hedgeCount := 0
// HEDGE SHORT ENTRY (When long position breaks support)
if hedgeShortEntry and hedgeCount < maxHedgePositions
entryPrice = close
[sl, tp] = calculateLevels(entryPrice, false)
hedgeName = "Hedge Short " + str.tostring(hedgeCount + 1)
strategy.entry(hedgeName, strategy.short, qty=1)
if useFixedSL
strategy.exit("Hedge Exit", hedgeName, stop=sl)
hedgeCount += 1
// HEDGE LONG ENTRY (When short position breaks resistance)
if hedgeLongEntry and hedgeCount < maxHedgePositions
entryPrice = close
[sl, tp] = calculateLevels(entryPrice, true)
hedgeName = "Hedge Long " + str.tostring(hedgeCount + 1)
strategy.entry(hedgeName, strategy.long, qty=1)
if useFixedSL
strategy.exit("Hedge Exit", hedgeName, stop=sl)
hedgeCount += 1
// Close hedges on retrace
if closeHedgeOnRetrace
// Close short hedges if price retraces back above previous low
if structure == "uptrend" and not na(prevLow) and close > prevLow and hedgeCount > 0
for i = 1 to hedgeCount
strategy.close("Hedge Short " + str.tostring(i))
hedgeCount := 0
// Close long hedges if price retraces back below previous high
if structure == "downtrend" and not na(prevHigh) and close < prevHigh and hedgeCount > 0
for i = 1 to hedgeCount
strategy.close("Hedge Long " + str.tostring(i))
hedgeCount := 0
// Reset position flags when flat
if strategy.position_size == 0
longPositionActive := false
shortPositionActive := false
hedgeCount := 0
// ========== VISUAL ELEMENTS ==========
// Plot swing points
plotshape(showSwingPoints and not na(pivotHigh) ? pivotHigh : na, "Pivot High", shape.triangledown, location.abovebar,
higherHigh ? higherHighColor : lowerHigh ? lowerHighColor : color.gray, size=size.small)
plotshape(showSwingPoints and not na(pivotLow) ? pivotLow : na, "Pivot Low", shape.triangleup, location.belowbar,
higherLow ? higherLowColor : lowerLow ? lowerLowColor : color.gray, size=size.small)
// Draw swing lines
if showSwingLines and array.size(swingHighs) >= 2
lastHigh = array.get(swingHighs, array.size(swingHighs) - 1)
lastHighBar = array.get(swingHighBars, array.size(swingHighBars) - 1)
prevHighVal = array.get(swingHighs, array.size(swingHighs) - 2)
prevHighBar = array.get(swingHighBars, array.size(swingHighBars) - 2)
if showSwingLines and array.size(swingLows) >= 2
lastLow = array.get(swingLows, array.size(swingLows) - 1)
lastLowBar = array.get(swingLowBars, array.size(swingLowBars) - 1)
prevLowVal = array.get(swingLows, array.size(swingLows) - 2)
prevLowBar = array.get(swingLowBars, array.size(swingLowBars) - 2)
// Plot entry signals
plotshape(longEntry, "Long Entry", shape.triangleup, location.belowbar, color.green, size=size.normal)
plotshape(shortEntry, "Short Entry", shape.triangledown, location.abovebar, color.red, size=size.normal)
plotshape(hedgeShortEntry, "Hedge Short", shape.xcross, location.abovebar, color.orange, size=size.small)
plotshape(hedgeLongEntry, "Hedge Long", shape.xcross, location.belowbar, color.aqua, size=size.small)
// Background
structBg = structure == "uptrend" ? color.new(color.green, 97) : structure == "downtrend" ? color.new(color.red, 97) : na
bgcolor(structBg)
// ========== ALERTS ==========
if longEntry
alert("PRIMARY LONG: Higher High break on " + syminfo.ticker, alert.freq_once_per_bar)
if shortEntry
alert("PRIMARY SHORT: Lower Low break on " + syminfo.ticker, alert.freq_once_per_bar)
if hedgeShortEntry
alert("HEDGE SHORT: Higher Low break (support failure) on " + syminfo.ticker, alert.freq_once_per_bar)
if hedgeLongEntry
alert("HEDGE LONG: Lower High break (resistance failure) on " + syminfo.ticker, alert.freq_once_per_bar)