En la carga de los recursos... Cargando...

Estrategia de ruptura de la SR

El autor:¿ Qué pasa?, Fecha: 2024-05-15 16:30:14
Las etiquetas:

Resumen general

La estrategia de ruptura de SR es una estrategia de ruptura de soporte y resistencia desarrollada sobre la base del indicador de búsqueda de ruptura de LonesomeTheBlue. La idea principal de esta estrategia es generar señales largas o cortas al juzgar si el precio de cierre rompe el nivel de soporte o resistencia.

Principio de la estrategia

Utilice las funciones pivothigh y pivotlow para calcular los máximos y mínimos durante un cierto período de tiempo y almacenarlos en matrices.
Determine si el precio de cierre actual es superior al nivel de resistencia. Si es así, se juzga como una ruptura alcista y se genera una señal larga.
Determine si el precio de cierre actual es inferior al nivel de soporte.
Después de generar una señal de negociación, calcular los precios de stop loss y take profit basándose en los coeficientes de stop loss y take profit establecidos, y establecer las órdenes de stop loss y take profit correspondientes.
Dibujar el rango de ruptura correspondiente de acuerdo con la dirección de ruptura.

Ventajas estratégicas

La ruptura de soporte y resistencia es una estrategia comercial clásica con cierta base práctica.
Mediante el uso de las funciones pivothigh y pivotlow para calcular los niveles de soporte y resistencia, las oportunidades de ruptura se pueden capturar con relativa precisión.
La estructura de código de esta estrategia es clara, y al almacenar máximos y mínimos en matrices, es conveniente para backtesting y optimización.
Se establecen el stop loss y el take profit, lo que puede controlar los riesgos relativamente bien.

Riesgos estratégicos

La estrategia de ruptura de soporte y resistencia tiene un mal rendimiento en mercados agitados y es propensa a frecuentes rupturas falsas.
Es posible que los coeficientes fijos de stop loss y take profit no puedan adaptarse a las diferentes condiciones del mercado, lo que resulta en un desequilibrio de riesgo y rendimiento.
Esta estrategia solo tiene en cuenta los factores de precios y no tiene en cuenta otros indicadores importantes como el volumen de operaciones, que pueden perder algunas señales importantes.

Dirección de optimización de la estrategia

Considere la posibilidad de introducir más indicadores técnicos, como el volumen de operaciones, el MACD, etc., para mejorar la precisión y fiabilidad de las señales.
En el caso de las operaciones de stop loss y take profit, considere el uso de un trailing stop o de un stop loss dinámico y de un take profit para adaptarse mejor a las diferentes condiciones del mercado.
Considere la posibilidad de introducir condiciones de filtrado, como el filtrado de tendencias, el filtrado de volatilidad, etc., para reducir las falsas rupturas en mercados agitados.
Considere la posibilidad de optimizar los niveles de soporte y resistencia, como el uso de períodos adaptativos, la introducción de niveles de Fibonacci, etc.

Resumen de las actividades

La estrategia de ruptura de SR es una estrategia comercial basada en la idea clásica de ruptura de soporte y resistencia. Utilizando las funciones pivothigh y pivotlow para calcular los niveles de soporte y resistencia, y para juzgar si el precio de cierre rompe estos niveles para generar señales comerciales. La ventaja de esta estrategia es que la idea es clara y fácil de implementar y optimizar; al mismo tiempo, también hay algunos riesgos, como un mal rendimiento en mercados agitados, y los riesgos que pueden ser causados por las tasas fijas de stop loss y take profit. En el futuro, podemos considerar la optimización y mejora de esta estrategia desde aspectos como indicadores técnicos, stop loss y take profit, condiciones de filtrado, optimización de soporte y resistencia, etc., para mejorar su estabilidad y rentabilidad.

/*backtest
start: 2024-05-07 00:00:00
end: 2024-05-14 00:00:00
period: 10m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © LonesomeTheBlue © chanu_lev10k

//@version=5
strategy('SR Breakout Strategy', overlay=true, max_bars_back=500, max_lines_count=400)
prd = input.int(defval=5, title='Period', minval=2)
bo_len = input.int(defval=71, title='Max Breakout Length', minval=30, maxval=300)
cwidthu = input.float(defval=3., title='Threshold Rate %', minval=1., maxval=10) / 100
mintest = input.int(defval=2, title='Minimum Number of Tests', minval=1)
bocolorup = input.color(defval=color.blue, title='Breakout Colors', inline='bocol')
bocolordown = input.color(defval=color.red, title='', inline='bocol')
// lstyle = input.string(defval=line.style_solid, title='Line Style')
issl = input.bool(title='SL', inline='linesl1', group='Stop Loss / Take Profit:', defval=false)
slpercent = input.float(title=', %', inline='linesl1', group='Stop Loss / Take Profit:', defval=18.0, minval=0.0, step=0.1)
istp = input.bool(title='TP', inline='linetp1', group='Stop Loss / Take Profit:', defval=false)
tppercent = input.float(title=', %', inline='linetp1', group='Stop Loss / Take Profit:', defval=18.0, minval=0.0, step=0.1)

//width
lll = math.max(math.min(bar_index, 300), 1)
float h_ = ta.highest(lll)
float l_ = ta.lowest(lll)
float chwidth = (h_ - l_) * cwidthu

// check if PH/PL
ph = ta.pivothigh(prd, prd)
pl = ta.pivotlow(prd, prd)

//keep Pivot Points and their locations in the arrays
var phval = array.new_float(0)
var phloc = array.new_int(0)
var plval = array.new_float(0)
var plloc = array.new_int(0)

// keep PH/PL levels and locations
if bool(ph)
    array.unshift(phval, ph)
    array.unshift(phloc, bar_index - prd)
    if array.size(phval) > 1  // cleanup old ones
        for x = array.size(phloc) - 1 to 1 by 1
            if bar_index - array.get(phloc, x) > bo_len
                array.pop(phloc)
                array.pop(phval)

if bool(pl)
    array.unshift(plval, pl)
    array.unshift(plloc, bar_index - prd)
    if array.size(plval) > 1  // cleanup old ones
        for x = array.size(plloc) - 1 to 1 by 1
            if bar_index - array.get(plloc, x) > bo_len
                array.pop(plloc)
                array.pop(plval)

// check bullish cup
float bomax = na
int bostart = bar_index
num = 0
hgst = ta.highest(prd)[1]
if array.size(phval) >= mintest and close > open and close > hgst
    bomax := array.get(phval, 0)
    xx = 0
    for x = 0 to array.size(phval) - 1 by 1
        if array.get(phval, x) >= close
            break
        xx := x
        bomax := math.max(bomax, array.get(phval, x))
        bomax
    if xx >= mintest and open <= bomax
        for x = 0 to xx by 1
            if array.get(phval, x) <= bomax and array.get(phval, x) >= bomax - chwidth
                num += 1
                bostart := array.get(phloc, x)
                bostart
        if num < mintest or hgst >= bomax
            bomax := na
            bomax

// if not na(bomax) and num >= mintest
//     line.new(x1=bar_index, y1=bomax, x2=bostart, y2=bomax, color=bocolorup)
//     line.new(x1=bar_index, y1=bomax - chwidth, x2=bostart, y2=bomax - chwidth, color=bocolorup)
//     line.new(x1=bostart, y1=bomax - chwidth, x2=bostart, y2=bomax, color=bocolorup)
//     line.new(x1=bar_index, y1=bomax - chwidth, x2=bar_index, y2=bomax, color=bocolorup)

plotshape(not na(bomax) and num >= mintest, location=location.belowbar, style=shape.triangleup, color=bocolorup, size=size.small)
//alertcondition(not na(bomax) and num >= mintest, title='Breakout', message='Breakout')

// check bearish cup
float bomin = na
bostart := bar_index
num1 = 0
lwst = ta.lowest(prd)[1]
if array.size(plval) >= mintest and close < open and close < lwst
    bomin := array.get(plval, 0)
    xx = 0
    for x = 0 to array.size(plval) - 1 by 1
        if array.get(plval, x) <= close
            break
        xx := x
        bomin := math.min(bomin, array.get(plval, x))
        bomin
    if xx >= mintest and open >= bomin
        for x = 0 to xx by 1
            if array.get(plval, x) >= bomin and array.get(plval, x) <= bomin + chwidth
                num1 += 1
                bostart := array.get(plloc, x)
                bostart
        if num1 < mintest or lwst <= bomin
            bomin := na
            bomin

// if not na(bomin) and num1 >= mintest
//     line.new(x1=bar_index, y1=bomin, x2=bostart, y2=bomin, color=bocolordown)
//     line.new(x1=bar_index, y1=bomin + chwidth, x2=bostart, y2=bomin + chwidth, color=bocolordown)
//     line.new(x1=bostart, y1=bomin + chwidth, x2=bostart, y2=bomin, color=bocolordown)
//     line.new(x1=bar_index, y1=bomin + chwidth, x2=bar_index, y2=bomin, color=bocolordown)

plotshape(not na(bomin) and num1 >= mintest, location=location.abovebar, style=shape.triangledown, color=bocolordown, size=size.small)

//alertcondition(not na(bomin) and num1 >= mintest, title='Breakdown', message='Breakdown')
//alertcondition(not na(bomax) and num >= mintest or not na(bomin) and num1 >= mintest, title='Breakout or Breakdown', message='Breakout or Breakdown')

// Long Short conditions
longCondition = not na(bomax) and num >= mintest
if longCondition
    strategy.entry('Long', strategy.long)
shortCondition = not na(bomin) and num1 >= mintest
if shortCondition
    strategy.entry('Short', strategy.short)

// Entry price / Take Profit / Stop Loss
//entryprice = strategy.position_avg_price
entryprice = ta.valuewhen(condition=longCondition or shortCondition, source=close, occurrence=0)
pm = longCondition ? 1 : shortCondition ? -1 : 1 / math.sign(strategy.position_size)
takeprofit = entryprice * (1 + pm * tppercent * 0.01)
stoploss = entryprice * (1 - pm * slpercent * 0.01)
strategy.exit(id='Exit Long', from_entry='Long', stop=issl ? stoploss : na, limit=istp ? takeprofit : na, alert_message='Exit Long')
strategy.exit(id='Exit Short', from_entry='Short', stop=issl ? stoploss : na, limit=istp ? takeprofit : na, alert_message='Exit Short')

Más.