Estrategia comercial para cuando el precio rompe la media móvil


Fecha de creación: 2023-12-15 16:28:12 Última modificación: 2023-12-15 16:28:12
Copiar: 0 Número de Visitas: 575
1
Seguir
1621
Seguidores

Estrategia comercial para cuando el precio rompe la media móvil

Descripción general

La estrategia de negociación de brecha de precio de doble dirección (en inglés: Dual Direction Price Breakthrough Moving Average Timing Trading Strategy) es una estrategia de negociación cuantitativa que utiliza la brecha de precio de la media para determinar el momento de comprar o vender. La estrategia utiliza la comparación de los precios con las medias móviles de un período determinado para generar una señal de negociación en función de si el precio sube o baja la media.

Principio de estrategia

La lógica central de esta estrategia es la siguiente:

  1. Utiliza la función EMA para calcular el promedio móvil de un período determinado (por ejemplo, 200 días).

  2. Compara la relación entre el precio de cierre y la magnitud de la EMA para determinar si el precio ha roto la EMA. En concreto, se considera que el precio está por encima de la EMA cuando el precio de cierre es mayor que la EMA en el día; se considera que el precio está por debajo de la EMA cuando el precio de cierre es menor que la EMA en el día.

  3. Cuando el precio está por encima del EMA, se genera una señal de compra; cuando el precio está por debajo del EMA, se genera una señal de venta.

  4. Al generar la señal, ponga una orden en una proporción determinada (por ejemplo, en el almacén completo) y luego establezca un precio de stop loss y un precio de parada.

  5. Cuando el precio alcanza el precio de stop loss o stop-loss, aplanar la posición.

  6. En este ciclo, se aprovecha la oportunidad de los precios de romper la línea media para sacar provecho.

La estrategia es sencilla, directa, fácil de entender y de implementar. Se obtiene una mejor puntualidad por la captura de señales de ruptura en líneas cortas. Pero también existe un cierto retraso y el riesgo de múltiples temblores.

Ventajas estratégicas

  • La lógica de la estrategia es simple, clara, fácil de entender y verificar.
  • Utilizando la característica de la línea media, hay una cierta capacidad de seguimiento de tendencias.
  • El número de transacciones es alto y es adecuado para operaciones de línea corta.
  • La respuesta rápida a los cambios de precio y la mejor manera de capturar el momento.

Riesgo estratégico

  • Hay un cierto retraso que puede hacer que se pierda el primer avance.
  • El problema de las transacciones frecuentes es que las rupturas son frecuentes.
  • En el caso de una reversión significativa, el stop loss puede ser cubierto.

Se puede optimizar a través de ajustes de parámetros, como ajustar los parámetros de la línea media, usar un juicio de indicadores más eficiente, reducir la frecuencia de las transacciones, etc. También se puede configurar un stop loss adaptativo o introducir condiciones de filtración para controlar el riesgo.

Dirección de optimización de la estrategia

  • Prueba diferentes tipos de medias y parámetros para encontrar mejores soluciones, como EMA, SMA, LWMA, etc.
  • Se han añadido condiciones de filtración para evitar múltiples transacciones convulsivas. Se han introducido juzgamientos auxiliares, como el volumen de transacción, la línea de Brin y el ATR.
  • Optimización y prueba de estrategias de detención de pérdidas para reducir el riesgo.
  • El sistema de negociación integrado, que combina varias estrategias, como la tendencia y la reversión.
  • La configuración de parámetros se ha añadido para que la estrategia sea más universal.

Resumir

La estrategia en su conjunto es simple e intuitiva, y la idea central es seguir la línea de medianía para capturar brechas a corto plazo en los precios. La ventaja es la agilidad de la reacción y la facilidad de implementación; la desventaja es el atraso y la lentitud.

Código Fuente de la Estrategia
/*backtest
start: 2022-12-08 00:00:00
end: 2023-12-14 00:00:00
period: 1d
basePeriod: 1h
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/

// Credits to the original Script - Range Filter DonovanWall https://www.tradingview.com/script/lut7sBgG-Range-Filter-DW/
// This version is the old version of the Range Filter with less settings to tinker with

//@version=5
strategy(title='Range Filter - B&S Signals', shorttitle='RF - B&S Signals', initial_capital=1000, currency=currency.GBP, default_qty_value=100, default_qty_type=strategy.percent_of_equity, commission_type=strategy.commission.percent, commission_value=0.075, overlay=true)


i_startTime = input(defval=timestamp('01 Jan 2020 12:00 +0000'), title='Backtest Start')
i_endTime = input(defval=timestamp('01 Jan 2024 12:00 +0000'), title='Backtest End')

inDateRange     = true
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Functions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
longLossPerc = input.float(title='Long Stop Loss (%)', minval=0.0, step=0.1, defval=1) * 0.01
shortLossPerc = input.float(title='Short Stop Loss (%)', minval=0.0, step=0.1, defval=1) * 0.01

longTakePerc = input.float(title='Long Take(%)', minval=0.0, step=0.1, defval=1) * 0.01
shortTakePerc = input.float(title='Short Take (%)', minval=0.0, step=0.1, defval=1) * 0.01

emaLength = input.int(200, title="EMA Length")

    // Determine stop loss price

//Range Size Function
rng_size(x, qty, n) =>
//    AC       = Cond_EMA(abs(x - x[1]), 1, n)
    wper = n * 2 - 1
    avrng = ta.ema(math.abs(x - x[1]), n)
    AC = ta.ema(avrng, wper) * qty
    rng_size = AC
    rng_size

//Range Filter Function
rng_filt(x, rng_, n) =>
    r = rng_
    var rfilt = array.new_float(2, x)
    array.set(rfilt, 1, array.get(rfilt, 0))
    if x - r > array.get(rfilt, 1)
        array.set(rfilt, 0, x - r)
    if x + r < array.get(rfilt, 1)
        array.set(rfilt, 0, x + r)
    rng_filt1 = array.get(rfilt, 0)

    hi_band = rng_filt1 + r
    lo_band = rng_filt1 - r
    rng_filt = rng_filt1
    [hi_band, lo_band, rng_filt]

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Range Source
rng_src = input(defval=close, title='Swing Source')

//Range Period
rng_per = input.int(defval=20, minval=1, title='Swing Period')

//Range Size Inputs
rng_qty = input.float(defval=3.5, minval=0.0000001, title='Swing Multiplier')

//Bar Colors
use_barcolor = input(defval=false, title='Bar Colors On/Off')

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Range Filter Values
[h_band, l_band, filt] = rng_filt(rng_src, rng_size(rng_src, rng_qty, rng_per), rng_per)

//Direction Conditions
var fdir = 0.0
fdir := filt > filt[1] ? 1 : filt < filt[1] ? -1 : fdir
upward = fdir == 1 ? 1 : 0
downward = fdir == -1 ? 1 : 0

//Trading Condition
longCond = rng_src > filt and rng_src > rng_src[1] and upward > 0 or rng_src > filt and rng_src < rng_src[1] and upward > 0
shortCond = rng_src < filt and rng_src < rng_src[1] and downward > 0 or rng_src < filt and rng_src > rng_src[1] and downward > 0

CondIni = 0
CondIni := longCond ? 1 : shortCond ? -1 : CondIni[1]
longCondition = longCond and CondIni[1] == -1
shortCondition = shortCond and CondIni[1] == 1

//Colors
filt_color = upward ? #05ff9b : downward ? #ff0583 : #cccccc
bar_color = upward and rng_src > filt ? rng_src > rng_src[1] ? #05ff9b : #00b36b : downward and rng_src < filt ? rng_src < rng_src[1] ? #ff0583 : #b8005d : #cccccc


ema = ta.ema(close,emaLength)

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Outputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
longStopPrice = strategy.position_avg_price * (1 - longLossPerc)
shortStopPrice = strategy.position_avg_price * (1 + shortLossPerc)

longTakePrice = strategy.position_avg_price * (1 + longTakePerc)
shortTakePrice = strategy.position_avg_price * (1 - shortTakePerc)

//Filter Plot
filt_plot = plot(filt, color=filt_color, linewidth=3, title='Filter', transp=67)

//Band Plots
h_band_plot = plot(h_band, color=color.new(#05ff9b, 100), title='High Band')
l_band_plot = plot(l_band, color=color.new(#ff0583, 100), title='Low Band')

//Band Fills
fill(h_band_plot, filt_plot, color=color.new(#00b36b, 92), title='High Band Fill')
fill(l_band_plot, filt_plot, color=color.new(#b8005d, 92), title='Low Band Fill')

//Bar Color
barcolor(use_barcolor ? bar_color : na)

if  inDateRange and close>ema
    strategy.entry("Long", strategy.long, when=longCondition)
    
if   inDateRange and close<ema
    strategy.entry("Short", strategy.short, when=shortCondition)


plot(ema)




//Plot Buy and Sell Labels
plotshape(longCondition, title='Buy Signal', text='BUY', textcolor=color.white, style=shape.labelup, size=size.normal, location=location.belowbar, color=color.new(color.green, 0))
plotshape(shortCondition, title='Sell Signal', text='SELL', textcolor=color.white, style=shape.labeldown, size=size.normal, location=location.abovebar, color=color.new(color.red, 0))

//Alerts
alertcondition(longCondition, title='Buy Alert', message='BUY')
alertcondition(shortCondition, title='Sell Alert', message='SELL')

if strategy.position_size > 0
    strategy.exit(id='Long', stop=longStopPrice, limit=longTakePrice)

if strategy.position_size < 0
    strategy.exit(id='Short', stop=shortStopPrice, limit=shortTakePrice)