Esta estratégia utiliza indicadores técnicos interperíodos para identificar a direção da tendência, combinados com a filtragem da tendência e a filtragem da volatilidade, para alcançar uma negociação de acompanhamento de tendências de baixo risco.
Use avanços de pontos altos e baixos para determinar os sinais de compra e venda.
O indicador Trendflex determina a direção da tendência principal. Este indicador combina técnicas de suavização dupla e pode identificar efetivamente as seções médias da tendência. Um valor acima de 1 indica uma tendência ascendente, enquanto um valor abaixo de -1 indica uma tendência descendente.
Use Bandas de Bollinger para identificar os intervalos de oscilação.
Usar stop loss e take profit para gerir posições.
Os indicadores transversais combinados com técnicas de dupla suavização podem identificar eficazmente as direcções da tendência e evitar oscilações dos mercados.
Considerando a direção da tendência e os padrões de volatilidade torna os sinais de negociação mais confiáveis.
As configurações razoáveis de stop loss e take profit bloqueiam os lucros e evitam que as perdas se expandam.
A estratégia é relativamente simples e fácil de implementar.
Os sinais de ruptura podem ter falsas rupturas, resultando em negociações erradas.
Os parâmetros fixos do ciclo não podem adaptar-se às alterações do mercado.
A ausência de paradas de preços não previne grandes perdas devido a condições extremas de mercado.
Os pontos fixos de take profit e stop loss não podem ser ajustados de forma inteligente de acordo com a volatilidade do mercado.
Considerar a adição de mais indicadores de avaliação da tendência para formar uma combinação de estratégias para melhorar a precisão do julgamento.
Adicionar módulos de identificação de oscilações para pausar a negociação quando a oscilação for grave para reduzir o risco.
Introduzir algoritmos de aprendizagem de máquina para obter otimização de parâmetros dinâmicos.
Adicionar módulos de stop loss de preço para parar perdas quando as perdas atingirem um determinado limiar.
Calcular os rácios take profit e stop loss com base na volatilidade do mercado para obter um ajuste inteligente do take profit e stop loss.
Em geral, essa estratégia é relativamente estável e confiável, ao mesmo tempo em que tem espaço para melhoria. A ideia central é determinar a direção da tendência em todos os ciclos e, em seguida, filtrar usando indicadores de força da tendência e indicadores de volatilidade para gerar sinais de alta qualidade. Esta estratégia simples e prática é muito adequada para rastrear tendências de médio e longo prazo.
/*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")