Estratégia de acompanhamento de tendências com base em média móvel quantitativa
ChaoZhang
Visão geral
A estratégia é simples e fácil de usar, e é capaz de acompanhar eficazmente as tendências do mercado.
Princípio da estratégia
Computação de linhas rápidas e lentas. Linhas rápidas são médias móveis quantitativas baseadas em períodos de linhas rápidas definidos pelo usuário, e linhas lentas são médias móveis quantitativas baseadas em períodos de linhas lentas.
Calcule a diferença entre as duas linhas. A linha rápida menos a linha lenta obtém a curva diferencial.
Quando a linha rápida atravessa a linha lenta, faça mais; quando a linha rápida atravessa a linha lenta, faça vazio.
Emitir um sinal de negociação. Quando a tendência é de alta, é emitido um sinal de alta; Quando a tendência é baixa, é emitido um sinal de baixa.
Configuração de Stop Loss. Configuração de Stop Loss através de uma porcentagem de Stop Loss fixa definida pelo usuário ou Stop Loss dinâmico baseado no ATR.
Condições de saída: Se um stop loss ou um sinal de reversão for acionado durante a manutenção da posição, a posição será liquidada.
Análise de vantagens
O uso de indicadores quantitativos para identificar tendências, não pode ser facilmente confundido com falsas descobertas.
A combinação de linhas rápidas e lentas filtra o ruído do mercado e evita transações frequentes.
A configuração Stop Loss é eficaz para controlar o risco de perda.
A lógica da estratégia é simples, clara e fácil de entender.
Parâmetros personalizáveis para atender às necessidades de diferentes variedades e períodos de tempo.
Análise de Riscos
A configuração inadequada dos parâmetros pode levar a uma frequência de negociação excessiva ou a uma tendência perdida.
O stop loss fixo pode ser demasiado mecânico para se adaptar às mudanças do mercado.
As mudanças na relação entre quantidade e preço podem afetar a eficácia dos indicadores de quantificação.
O risco 1 pode ser encontrado através de parâmetros de otimização.
O risco 2 pode ser substituído por um stop fixo com um stop ATR dinâmico.
Risco 3: O impacto da mudança de volume de negócios na estratégia.
Direção de otimização
Teste diferentes combinações de parâmetros de linha rápida e lenta.
Tente outros indicadores de tipo de preço, como OBV, William, etc.
Aumento do stop loss baseado na volatilidade.
Avaliação da eficácia em combinação com outros indicadores.
Avaliação da eficácia em diferentes variedades de transações.
Resumir
A estratégia segue a tendência por meio de combinações de linhas rápidas e lentas de medias quantificadas, a lógica de negociação é simples e clara, e os parâmetros podem ser ajustados de forma otimizada. A configuração de stop loss ajuda a controlar o risco. A eficácia da combinação de outros indicadores pode ser avaliada posteriormente.
/*backtest
start: 2023-08-18 00:00:00
end: 2023-09-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("EVWMA 6HR", overlay=false, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
// Credit to QuantNomad for the main idea behind this code
/////////////// Time Frame ///////////////
_1 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
///////////// EVWMA /////////////
_2 = input(false, "════════ EVMA ═══════")
fast_sum_length = input(5, title = "Fast Sum Length", type = input.integer)
slow_sum_length = input(11, title = "Slow Sum Length", type = input.integer)
fast_vol_period = sum(volume, fast_sum_length)
slow_vol_period = sum(volume, slow_sum_length)
fast_evwma = 0.0
fast_evwma := ((fast_vol_period - volume) * nz(fast_evwma[1], close) + volume * close) / (fast_vol_period)
slow_evwma = 0.0
slow_evwma := ((slow_vol_period - volume) * nz(slow_evwma[1], close) + volume * close) / (slow_vol_period)
diff = fast_evwma - slow_evwma
/////////////// Strategy ///////////////
long = fast_evwma > slow_evwma
short = fast_evwma < slow_evwma
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
SL_type = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inp = input(9.0, title='Fixed Stop Loss %') / 100
atrLkb = input(20, minval=1, title='ATR Stop Period')
atrMult = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop1 = 0.0
longStop1 := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop1[1]
shortStop1 = 0.0
shortStop1 := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop1[1]
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
_5 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")
/////////////// Execution ///////////////
if testPeriod()
if useLongs
strategy.entry("L", strategy.long, when=long)
strategy.exit("L SL", "L", stop = SL_type == "Fixed" ? long_sl : longStop1, when=since_longEntry > -1)
if useShorts
strategy.exit("S SL", "S", stop = SL_type == "Fixed" ? short_sl : shortStop1, when=since_shortEntry > -1)
strategy.entry("S", strategy.short, when=short)
if not useShorts
strategy.close("L", when=short)
if not useLongs
strategy.close("S", when=long)
/////////////// Plotting ///////////////
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
p1 = plot(diff, title = "Delta", color = long ? color.lime : short ? color.red : na, transp=0)
p2 = plot(0, color = color.white)
fill(p1, p2, color = long ? color.lime : short ? color.red : na, transp=60)