Estrategia de filtrado del análisis de corrección de índices


Fecha de creación: 2023-12-13 15:55:07 Última modificación: 2023-12-13 15:55:07
Copiar: 0 Número de Visitas: 637
avatar of ChaoZhang ChaoZhang
1
Seguir
1621
Seguidores

Estrategia de filtrado del análisis de corrección de índices

Descripción general

La estrategia utiliza una combinación de operaciones de simulación y promedios móviles de índices para implementar un filtro de tendencias de alta aleatoriedad para determinar la dirección de la posición. La estrategia primero calcula si el precio se divide por el saldo de un número establecido como 0, y si es 0, aparece una señal de transacción. Esta señal se queda en blanco si está por debajo de la media móvil del índice; si está por encima de la media móvil del índice, más. La estrategia combina la aleatoriedad de las operaciones matemáticas con el juicio de tendencias de los indicadores técnicos, utilizando verificaciones cruzadas entre diferentes indicadores periódicos para filtrar de manera efectiva el comportamiento aleatorio que afecta parcialmente el precio.

Principio de estrategia

  1. Configure el valor de entrada de precio a como precio de cierre, que se puede modificar; configure el valor de división b como 4, que se puede modificar.
  2. Calcula el resto de a dividido por b módulo y determina si el resto es 0。
  3. Establece una media móvil de la longitud del índice MALen, con un ciclo por defecto de 70, como indicador de tendencias de precios a medio y largo plazo.
  4. Cuando el saldo modulo es 0, se genera una señal de transacción evennumber, y la relación con la EMA determina la dirección. Cuando el precio cruza la línea EMA arriba, se genera una señal de compra BUY; cuando el precio cruza la línea EMA debajo, se genera una señal de venta SELL.
  5. Las entradas de comercio entran en posiciones de venta o venta libre siguiendo la dirección de la señal. La estrategia puede limitar la apertura de posiciones a la inversa para controlar el número de operaciones.
  6. Las condiciones de parada se establecen de acuerdo con tres formas de parada: parada fija, parada ATR y parada de rango de fluctuación de precios. La condición de parada es la inversión de la parada.
  7. Se puede elegir si se usa el Stop Loss móvil para bloquear más ganancias, no se usa por defecto.

Análisis de las ventajas

  1. La aleatoriedad de la simulación evita el impacto de las fluctuaciones de precios y, en combinación con el juicio de tendencias de las medias móviles, puede filtrar eficazmente algunas señales no válidas.
  2. Los promedios móviles exponenciales se utilizan como indicadores de tendencias a medio y largo plazo, combinados con señales de corto plazo de operaciones modulares, para permitir la verificación en múltiples niveles y evitar señales falsas.
  3. La configuración de parámetros personalizables es muy flexible, se pueden ajustar los parámetros según los diferentes mercados para encontrar la combinación óptima de parámetros.
  4. La integración de varios métodos de stop loss permite controlar el riesgo. Al mismo tiempo, se establecen condiciones de stop-loss para bloquear las ganancias.
  5. Apoya la apertura de posiciones inversa directa, se puede cambiar la dirección de la posición sin problemas. También se puede desactivar esta función para reducir el número de operaciones.

Análisis de riesgos

  1. La configuración incorrecta de los parámetros puede generar demasiadas señales de negociación, aumentando la frecuencia de las transacciones y los costos de los puntos de deslizamiento.
  2. El promedio móvil es el único indicador de tendencias que puede generar un retraso y perder el momento de la reversión de los precios.
  3. El método de stop loss fijo puede ser demasiado mecánico para adaptarse a las fluctuaciones del mercado.
  4. La apertura directa de posiciones inversa aumenta la frecuencia de ajustes de posiciones y aumenta los costos y el riesgo de las transacciones.

Dirección de optimización

  1. Se pueden probar diferentes indicadores de la línea media en lugar de la EMA, o en combinación con la EMA y otras líneas medias, para ver si se puede mejorar la rentabilidad.
  2. Se puede intentar combinar el filtro de cálculo de módulos con otras estrategias, como la banda de Brin, la forma de la línea K, etc., para formar un filtro más estable.
  3. Se puede estudiar la forma de adaptarse a la parada de pérdidas, ajustando la distancia de parada de acuerdo con la volatilidad del mercado.
  4. Se puede configurar el número de transacciones o el límite de pérdidas para limitar el número de posiciones abiertas directamente al revés.

Resumir

La estrategia permite una combinación efectiva de filtración aleatoria y determinación de tendencias de las medias móviles a través de operaciones de simulación, la configuración de parámetros es flexible y se puede ajustar y optimizar según los diferentes entornos del mercado para obtener una señal de negociación más confiable. Al mismo tiempo, integra varios mecanismos de control de riesgo de pérdidas, así como paradas y paradas móviles para bloquear las ganancias. La estrategia tiene una idea general clara, es fácil de entender y modificar, vale la pena realizar más pruebas y optimizaciones, y tiene un gran potencial de aplicación en el mercado real.

Código Fuente de la Estrategia 
/*backtest
start: 2023-11-12 00:00:00
end: 2023-12-12 00:00:00
period: 1h
basePeriod: 15m
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/
// © tweakerID

// To understand this strategy first we need to look into the Modulo (%) operator. The modulo returns the remainder numerator 
// of a division's quotient (the result). If we do 5 / 3, we get 1 and 2/3 as a result, where the remainder is 2 (two thirds, in this case). This can be
// used for many things, for example to determine when a number divides evenly into another number. If we divide 3/3, our result is 1,
// with no remainder numerator, hence our modulo result is 0. In this strategy, we compare a given number (divisor, user defined) with the
// the closing price of every candle (dividend, modifiable from the inputs panel) to determine if the result between their division is an even number. 
// If the answer is true, we have an entry signal. If this signal occurs below the EMA (length is defined by the user) we go short and
// viceversa for longs. This logic can be reversed. In this case, the modulo works as a random-like filter for a moving average strategy
// that usually struggles when the market is ranging.

//@version=4

//@version=4
strategy("Modulo Logic + EMA Strat", 
     overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

a=input(close, title="Dividend")
b=input(4, title="Divisor")
usemod=input(true, title="Use Modulo Logic")
MALen=input(70, title="EMA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(4, step=.1, title="ATR Multiple")
i_TPRRR = input(1, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR

// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na 
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na 
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR


// Strategy Stop

float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na

/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

modulo=a%b
evennumber=modulo==0
MA=ema(close, MALen)
plot(MA)

BUY=usemod ? evennumber and close > MA : close > MA
SELL=usemod ? evennumber and close < MA : close < MA

//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)


SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP

//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
 -strategy.position_avg_price
trailOffset     = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
    tstop := high- trailOffset - dif
    if tstop<tstop[1]
        tstop:=tstop[1]
else
    tstop := na
StrailOffset     = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0 
 and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
    Ststop := low+ StrailOffset + Sdif
    if Ststop>Ststop[1]
        Ststop:=Ststop[1]
else
    Ststop := na

strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", size=size.auto)
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)