A estratégia de cruzamento da média móvel é uma estratégia de negociação comumente usada baseada em médias móveis. Ela usa o cruzamento de uma média móvel mais rápida e uma média móvel mais lenta como sinais de negociação. Quando a média móvel mais rápida cruza acima da média móvel mais lenta de baixo, é um sinal de compra. Quando a média móvel mais rápida cruza abaixo da média móvel mais lenta de cima, é um sinal de venda. Esta estratégia usa MA de 50 dias como MA mais rápida e MA de 200 dias como MA mais lenta.
A lógica central desta estratégia é baseada na teoria das médias móveis. As médias móveis podem suavizar efetivamente as flutuações de preços e indicar tendências de preços. O MA mais rápido é mais sensível às mudanças de preço e pode capturar pontos de reversão de tendência. O MA mais lento é menos sensível às mudanças de preço e pode filtrar flutuações de curto prazo.
Especificamente, esta estratégia define primeiro a MA de 50 dias e a MA de 200 dias. A condição de entrada longa é definida quando a MA mais rápida cruza acima da MA mais lenta. A condição de entrada curta é definida quando a MA mais rápida cruza abaixo da MA mais lenta. Para evitar que as negociações se sobreponham, a estratégia usa as bandeiras isEntry e isExit para controle. Quando a condição de entrada é atendida, isEntry é definida como verdadeira. Quando a condição de saída é atendida, isExit é definida como verdadeira. Uma posição longa só será aberta quando isEntry for falsa e um sinal de compra aparecer. Uma posição curta só será aberta quando isExit for falsa e um sinal de venda aparecer.
Além disso, a estratégia também define níveis de take profit e stop loss. Os usuários podem definir a distância percentual TP/SL através de entradas. Os preços TP e SL serão calculados com base na porcentagem do preço de entrada. Quando o tamanho da posição for maior que 0, TP e SL serão executados com base na porcentagem longa TP/SL. Quando o tamanho da posição for menor que 0, TP e SL serão baseados na porcentagem curta TP/SL.
As vantagens desta estratégia incluem:
Simples de implementar, é negociado exclusivamente com base em cruzes MA, adequado para iniciantes sem experiência de negociação.
As médias móveis podem filtrar as flutuações de curto prazo e evitar serem interrompidas.
Os usuários podem otimizar parâmetros como períodos de MA e níveis de TP/SL.
A estratégia traça os principais MAs, entradas e níveis de TP/SL no gráfico.
Estrutura estratégica completa, podem ser adicionados novos sinais e indicadores para a melhorar.
Os riscos desta estratégia incluem:
Incapaz de parar a perda durante eventos de mercado extremos, levando a uma grande redução.
São propensos a falhas nos mercados, causando perdas consecutivas.
Os custos de negociação não são tidos em conta, pois as taxas e os deslizamentos na negociação real terão um impacto significativo na rentabilidade.
As condições reais do mercado são complexas e os resultados dos backtests podem não representar o desempenho em tempo real.
As soluções incluem:
Usar um stop loss mais amplo, ou adicionar um stop loss de ruptura adicional.
Aumentar a distância MA, reduzir a frequência de negociação ou adicionar outros filtros.
Considere os custos reais de negociação, defina um espaço de lucro mais amplo.
Otimizar gradualmente os parâmetros e reduzir o sobreajuste, tendo em conta as condições de mercado em evolução.
Esta estratégia pode ser otimizada nos seguintes aspectos:
Teste diferentes combinações de parâmetros para encontrar os parâmetros ideais, como os períodos de MA.
Adicionar outros indicadores como filtros para evitar problemas, tais como MACD, KD etc.
Otimizar a estratégia de stop loss para uma melhor gestão do risco, como trailing stop loss.
Aumentar o tamanho da posição com alavancagem para aumentar os lucros, controlando o risco.
Considere os custos de negociação, otimize os parâmetros para negociação ao vivo.
Avaliação da estabilidade dos parâmetros utilizando métodos estatísticos para reduzir o sobreajuste.
Em conclusão, esta estratégia de cruzamento MA tem uma lógica clara e é simples de implementar, adequada como uma estratégia introdutória para a negociação de algo. Mas também tem riscos e limitações. Parâmetro cuidadoso e otimização de filtro e controle de risco são necessários para alcançar lucros constantes. Esta estratégia tem grande extensão para os usuários inovarem e otimizarem com base nela para atender ao seu próprio estilo de negociação.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-10-09 00:00:00
period: 3m
basePeriod: 1m
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/
// © gjfsdrtytru
//@version=4
strategy("Backtest Engine", "Backtest", overlay=true, commission_type=strategy.commission.percent, commission_value=0.07, initial_capital = 1000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, currency = currency.USD)
// Start code here...
fastMA = sma(close,50)
slowMA = sma(close,200)
plot(fastMA, "Fast MA", color.blue)
plot(slowMA, "Slow MA", color.red)
// Long Enrty/Exit
longCondition = crossover(fastMA,slowMA)
closeLong = crossover(slowMA,fastMA)
// Short Enrty/Exit
shortCondition = crossover(slowMA,fastMA)
closeShort = crossover(fastMA,slowMA)
// Bot web-link alert - {{strategy.order.comment}}
botLONG = "ENTRY LONG ALERT"
botCLOSELONG = "CLOSE LONG ALERT"
botSHORT = "ENTRY SHORT ALERT"
botCLOSESHORT = "CLOSE SHORT ALERT"
//////////////////////////////////////////////////////////////////
//////////////////////// BACKTEST ENGINE \\\\\\\\\\\\\\\\\\\\\\\\\
/////////////////// [NO USER INPUT REQUIRED] /////////////////////
//////////////////////////////////////////////////////////////////
// Time period
testStartYear = input(2020, "Backtest Start Year")
testStartMonth = input(5, "Backtest Start Month")
testStartDay = input(11, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
periodLength = input(3650, "Backtest Period (days)", minval=0,tooltip="Days until strategy ends") * 86400000 // convert days into UNIX time
testPeriodStop = testPeriodStart + periodLength
testPeriod() =>
time >= testPeriodStart and time <= testPeriodStop ? true : false
// Convert Take profit and Stop loss to percentage
longTP = input(title="Long Take Profit (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
longSL = input(title="Long Stop Loss (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
shortTP = input(title="Short Take Profit (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
shortSL = input(title="Short Stop Loss (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
// 0% TP/SL = OFF (a value of 0 turns off TP/SL feature)
longProfitPerc = longTP == 0 ? 1000 : longTP
longStopPerc = longSL == 0 ? 1 : longSL
shortProfitPerc = shortTP == 0 ? 1 : shortTP
shortStopPerc = shortSL == 0 ? 1000 : shortSL
// Determine TP/SL price based on percentage given
longProfitPrice = strategy.position_avg_price * (1 + longProfitPerc)
longStopPrice = strategy.position_avg_price * (1 - longStopPerc)
shortProfitPrice = strategy.position_avg_price * (1 - shortProfitPerc)
shortStopPrice = strategy.position_avg_price * (1 + shortStopPerc)
// Anti-overlap
isEntry_Long = false
isEntry_Long := nz(isEntry_Long[1], false)
isExit_Long = false
isExit_Long := nz(isExit_Long[1], false)
isEntry_Short = false
isEntry_Short := nz(isEntry_Short[1], false)
isExit_Short = false
isExit_Short := nz(isExit_Short[1], false)
entryLong = not isEntry_Long and longCondition
exitLong = not isExit_Long and closeLong
entryShort = not isEntry_Short and shortCondition
exitShort = not isExit_Short and closeShort
if (entryLong)
isEntry_Long := true
isExit_Long := false
if (exitLong)
isEntry_Long := false
isExit_Long := true
if (entryShort)
isEntry_Short := true
isExit_Short := false
if (exitShort)
isEntry_Short := false
isExit_Short := true
// Order Execution
if testPeriod()
if entryLong
strategy.entry(id="Long", long=true, when = entryLong, comment=botLONG) // {{strategy.order.comment}}
if entryShort
strategy.entry(id="Short", long=false, when = entryShort, comment=botSHORT) // {{strategy.order.comment}}
// TP/SL Execution
if (strategy.position_size > 0)
strategy.exit(id="Long SL/TP", from_entry="Long", limit=longProfitPrice, stop=longStopPrice)
strategy.close(id="Long", when=exitLong, comment=botCLOSELONG) // {{strategy.order.comment}}
if (strategy.position_size < 0)
strategy.exit(id="Short TP/SL", from_entry="Short", limit=shortProfitPrice, stop=shortStopPrice)
strategy.close(id="Short", when=exitShort, comment=botCLOSESHORT) // {{strategy.order.comment}}
// Draw Entry, TP and SL Levels for Long Positions
plot(strategy.position_size > 0 ? longTP == 0 ? na : longProfitPrice : na, style=plot.style_linebr, color=color.green, title="Long TP")
plot(strategy.position_size > 0 ? strategy.position_avg_price : na, style=plot.style_linebr, color=color.blue, title="Long Entry")
plot(strategy.position_size > 0 ? longSL == 0 ? na : longStopPrice : na, style=plot.style_linebr, color=color.red, title="Long SL")
// Draw Entry, TP and SL Levels for Short Positions
plot(strategy.position_size < 0 ? shortTP == 0 ? na : shortProfitPrice : na, style=plot.style_linebr, color=color.green, title="Short TP")
plot(strategy.position_size < 0 ? strategy.position_avg_price : na, style=plot.style_linebr, color=color.blue, title="Short Entry")
plot(strategy.position_size < 0 ? shortSL == 0 ? na : shortStopPrice : na, style=plot.style_linebr, color=color.red, title="Short SL")