Esta estrategia utiliza indicadores técnicos transitorios para identificar la dirección de la tendencia, combinados con el filtrado de tendencias y el filtrado de volatilidad, para lograr operaciones de seguimiento de tendencias de bajo riesgo.
Utilizar los avances de puntos altos y bajos para determinar las señales de compra y venta.
El indicador Trendflex determina la dirección de la tendencia principal. Este indicador combina técnicas de doble suavizado y puede identificar efectivamente las secciones medias de la tendencia. Un valor por encima de 1 indica una tendencia al alza, mientras que un valor por debajo de -1 indica una tendencia a la baja. Aquí se requiere Trendflex > 1 para largos y < -1 para cortos, filtrando así los estados de consolidación.
Utilice las bandas de Bollinger para identificar los rangos de oscilación.
Utilice el stop loss móvil y el take profit para gestionar las posiciones.
Los indicadores transversales combinados con técnicas de doble suavizado pueden identificar eficazmente las tendencias y evitar oscilaciones de los mercados.
Teniendo en cuenta tanto la dirección de la tendencia y los patrones de volatilidad hace que las señales comerciales más confiables.
Las configuraciones razonables de stop loss y take profit bloquean las ganancias y evitan que las pérdidas se expandan.
La estrategia es relativamente simple y fácil de aplicar.
Las señales de ruptura pueden tener fallas falsas, lo que resulta en operaciones incorrectas.
Los parámetros de ciclo fijo no pueden adaptarse a los cambios del mercado. Se puede considerar la optimización dinámica de los parámetros.
La falta de paradas de precios no evita grandes pérdidas por condiciones extremas de mercado.
Los puntos fijos de toma de ganancias y stop loss no pueden ajustarse de manera inteligente de acuerdo con la volatilidad del mercado.
Considere la posibilidad de añadir más indicadores de juicio de tendencia para formar una combinación de estrategias para mejorar la precisión del juicio.
Añadir módulos de identificación de oscilaciones para pausar la negociación cuando la oscilación es severa para reducir el riesgo.
Introducir algoritmos de aprendizaje automático para lograr la optimización de parámetros dinámicos.
Añadir módulos de stop loss de precios para detener las pérdidas cuando las pérdidas alcanzan un cierto umbral.
Calcular los ratios de toma de ganancias y de parada de pérdidas basados en la volatilidad del mercado para lograr un ajuste inteligente de toma de ganancias y parada de pérdidas.
En general, esta estrategia es relativamente estable y confiable, mientras que también tiene margen de mejora. La idea central es determinar la dirección de la tendencia a través de los ciclos, y luego filtrar utilizando indicadores de fuerza de tendencia e indicadores de volatilidad para generar señales de alta calidad. Esta estrategia simple y práctica es muy adecuada para rastrear tendencias a mediano y largo plazo. Al introducir juicios más condicionales y optimización de parámetros dinámicos, el efecto de la estrategia puede mejorarse aún más.
/*backtest
start: 2023-08-27 00:00:00
end: 2023-09-26 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Eltrut", shorttitle="Eltrut Strat", overlay=true, pyramiding=0, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)
testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// R E F L E X / T R E N D F L E X
f_supersmoother(_src,_len)=>
pi = 2 * asin(1)
_a = exp(-sqrt(2) * pi / _len)
_c2 = 2 * _a * cos(sqrt(2) * pi / _len)
_c3 = -_a * _a
_c1 = 1 - _c2 - _c3
_out = 0.0
_out := _c1 * _src + _c2 * nz(_out[1],nz(_src[1],_src)) + _c3 * nz(_out[2],nz(_src[2],nz(_src[1],_src)))
f_IQIFM(_src1,_max)=>
_src = _src1 < 0.001 ? _src1 * 10000 : _src1
_imult = 0.635, _qmult = 0.338 , _inphase = 0.0, _quad = 0.0
_re = 0.0, _im = 0.0, _deltaphase = 0.0, _instper = 0.0, _per = 0.0, _v4 = 0.0
_v1 = _src - nz(_src[7])
_inphase := 1.25 * (nz(_v1[4]) - _imult * _v1[2]) + _imult * nz(_inphase[3])
_quad := _v1[2] - _qmult * _v1 + _qmult * nz(_quad[2])
_re := 0.2 * (_inphase * _inphase[1] + _quad * _quad[1]) + 0.8 * nz(_re[1])
_im := 0.2 * (_inphase * _quad[1] - _inphase[1] * _quad) + 0.8 * nz(_im[1])
if _re != 0.0
_deltaphase := atan(_im / _re)
for i = 0 to _max
_v4 := _v4 + _deltaphase[i]
if _v4 > 4 * asin(1) and _instper == 0.0
_instper := i
if _instper == 0.0
_instper := nz(_instper[1])
_per := 0.25 * _instper + 0.75 * nz(_per[1])
_per
f_flex(_src1, _fixed_len, _reflex) =>
_src = _src1
_len = _fixed_len
_ss1 = f_supersmoother(_src, _len)
_ss = _ss1
_slope = (_ss[_len] - _ss) / _len
_sum = 0.0
for _i = 1 to _len
_c1 = _reflex ? _ss + _i * _slope - _ss[_i] : _ss - _ss[_i]
_sum := _sum + _c1
_sum := _sum / _len
_ms = 0.0
_ms := 0.04 * pow(_sum,2) + 0.96 * nz(_ms[1])
_flex1 = _ms != 0 ? _sum / sqrt(nz(_ms)) : 0.0
_flex = _flex1
_flex
rflx = f_flex(close, 20, true)
trndflx = f_flex(close, 20, false)
// S I G N A L
hi7 = highest(7)
lo7 = lowest(7)
long_cond = crossunder(close, lo7[1])
short_cond = crossover(close, hi7[1])
// F I L T E R S
long_filter1 = trndflx < 1
short_filter1 = trndflx > -1
basis = sma(close, 35)
dev = 3 * stdev(close, 35)
long_filter2 = close > basis - dev
short_filter2 = close < basis + dev
// S T R A T E G Y
long = long_cond and long_filter1 and long_filter2
short = short_cond and short_filter1 and short_filter2
if( true)
strategy.entry("Long", strategy.long, when = long)
strategy.entry("Long", strategy.long, when = short)
// User Options to Change Inputs (%)
stopPer = input(3, title='Stop Loss %', type=input.float) / 100
takePer = input(9, title='Take Profit %', type=input.float) / 100
// Determine where you've entered and in what direction
longStop = strategy.position_avg_price * (1 - stopPer)
shortStop = strategy.position_avg_price * (1 + stopPer)
shortTake = strategy.position_avg_price * (1 - takePer)
longTake = strategy.position_avg_price * (1 + takePer)
if strategy.position_size > 0
strategy.exit(id="Exit Long", stop=longStop, limit=longTake)
if strategy.position_size < 0
strategy.exit(id="Exit Short", stop=shortStop, limit=shortTake)
// P L O T
plotshape(long, color = #1e90ff, text = "", style=shape.triangleup, location=location.belowbar, size=size.tiny)
plotshape(short, color = #ff69b4, text = "", style=shape.triangledown, location=location.abovebar, size=size.tiny)
alertcondition(long, "Long", "Enter Long")
alertcondition(short, "Short", "Enter S")