Estratégia de Crossover de Combinação de Onze Médias Móveis


Data de criação: 2024-01-15 13:57:53 última modificação: 2024-01-15 13:57:53
cópia: 3 Cliques: 710
1
focar em
1617
Seguidores

Estratégia de Crossover de Combinação de Onze Médias Móveis

Visão geral

A combinação de estratégias usa o cruzamento de 11 diferentes tipos de médias móveis para fazer o sobre e o abaixo. As 11 médias móveis usadas incluem: média móvel simples (SMA), média móvel indexada (EMA), média móvel ponderada (WMA), média móvel ponderada (VWMA), média móvel plana (SMMA), média móvel binária (DEMA), média móvel tripla (TEMA), média móvel de Hull (HMA), média móvel de atraso zero (EMAZ), média móvel triangular (TMA) e deslizador de superplanos (SSMA).

Esta estratégia permite configurar duas médias móveis, uma mais rápida e uma mais lenta, escolhendo entre 11 opções. Quando uma MA mais rápida cruza uma MA mais lenta, um sinal de duplicidade é gerado. Quando uma MA mais rápida cruza uma MA mais lenta, um sinal de duplicidade é gerado.

As funções adicionais incluem a configuração de degraus, paradas e níveis de perda.

Estratégia Lógica

A lógica da estratégia central depende de um cruzamento entre duas médias móveis para determinar a entrada e a saída.

As condições de entrada são:

Mais entradas: MA rápido > MA lento
Entradas aéreas: MA rápido < MA lento

A saída é determinada por um dos seguintes três critérios:

  1. Nível de suspensão alcançado
  2. Nível de stop loss alcançado
  3. Geração de sinal inverso ((Média móvel cruzada na direção oposta))

A estratégia permite a configuração de parâmetros-chave, como o tipo e a duração do MA, a configuração de gradiente, a paralisação e a porcentagem de parada. Isso oferece flexibilidade para otimizar a estratégia de acordo com diferentes condições de mercado e preferências de risco.

Vantagens

  • Combinação de 11 tipos diferentes de MA para produzir um sinal forte
  • Flexibilidade na configuração dos principais parâmetros
  • Funções de suspensão e parada de perdas Proteção de lucros, limitação de perdas
  • Os gradientes permitem aumentar a posição em uma forte tendência

Riscos

  • Como qualquer indicador técnico, o cruzamento MA pode gerar um sinal errado.
  • Otimização excessiva das condições atuais do mercado pode reduzir o desempenho futuro
  • O Hard Stop saiu cedo da correta negociação de uma grande volatilidade

Pode-se reforçar o gerenciamento de risco através da confirmação de preços para o uso de sinais de entrada, o uso de tracking stop loss em vez de hard stop loss e evitar a otimização excessiva.

Optimizar o espaço

A estratégia pode ser melhorada de várias maneiras:

  1. Adição de filtros adicionais, como verificação de volume e preço, antes da entrada
  2. Testar sistematicamente o desempenho de diferentes tipos de MA, selecionando os 1-2 melhores
  3. Optimizar o comprimento do MA para uma variedade de transações e período de tempo específicos
  4. O uso de tracking stop-loss em vez de stop-hard
  5. A tendência de crescimento é a de adição de fases de parada.

Resumir

A estratégia de cruzamento de uma média móvel eleva-se oferece uma forma de cruzamento de negociação sistemática. Ao combinar sinais de vários indicadores de MA e permitir a configuração de parâmetros-chave, ela oferece uma estrutura de negociação robusta e flexível. A otimização e o gerenciamento de risco terão um papel fundamental para otimizar o desempenho.

Código-fonte da estratégia
/*backtest
start: 2023-12-15 00:00:00
end: 2024-01-14 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3

strategy(title = "[STRATEGY] MA Cross Eleven", overlay = true)

// MA - type, source, length

//  MA - type, source, length
//  SMA --> Simple
//  EMA --> Exponential
//  WMA --> Weighted
//  VWMA --> Volume Weighted
//  SMMA --> Smoothed
//  DEMA --> Double Exponential
//  TEMA --> Triple Exponential
//  HMA --> Hull
//  TMA --> Triangular
//  SSMA --> SuperSmoother filter
//  ZEMA --> Zero Lag Exponential

type = input(defval="ZEMA", title="MA Type: ", options=["SMA", "EMA", "WMA", "VWMA", "SMMA", "DEMA", "TEMA", "HullMA", "ZEMA", "TMA", "SSMA"])
len1 = input(defval=8, title="Fast MA Length", minval=1)
srcclose1 = input(close, "Fast MA Source")
len2 = input(defval=21, title="Slow MA Length", minval=1)
srcclose2 = input(close, "Slow MA Source")

// Returns MA input selection variant, default to SMA if blank or typo.

variant(type, src, len) =>
    v1 = sma(src, len)                                                  // Simple
    v2 = ema(src, len)                                                  // Exponential
    v3 = wma(src, len)                                                  // Weighted
    v4 = vwma(src, len)                                                 // Volume Weighted
    v5 = 0.0
    v5 := na(v5[1]) ? sma(src, len) : (v5[1] * (len - 1) + src) / len    // Smoothed
    v6 = 2 * v2 - ema(v2, len)                                          // Double Exponential
    v7 = 3 * (v2 - ema(v2, len)) + ema(ema(v2, len), len)               // Triple Exponential
    v8 = wma(2 * wma(src, len / 2) - wma(src, len), round(sqrt(len)))   // Hull
    v11 = sma(sma(src,len),len)                                         // Triangular
    // SuperSmoother filter
    // © 2013  John F. Ehlers
    a1 = exp(-1.414*3.14159 / len)
    b1 = 2*a1*cos(1.414*3.14159 / len)
    c2 = b1
    c3 = (-a1)*a1
    c1 = 1 - c2 - c3
    v9 = 0.0
    v9 := c1*(src + nz(src[1])) / 2 + c2*nz(v9[1]) + c3*nz(v9[2])
    // Zero Lag Exponential
    e = ema(v2, len)
    v10 = v2+(v2-e)
    // return variant, defaults to SMA if input invalid.
    type=="EMA"?v2 : type=="WMA"?v3 : type=="VWMA"?v4 : type=="SMMA"?v5 : type=="DEMA"?v6 : type=="TEMA"?v7 : type=="HullMA"?v8 : type=="SSMA"?v9 : type=="ZEMA"?v10 : type=="TMA"? v11: v1

ma_1 = variant(type, srcclose1, len1)
ma_2 = variant(type, srcclose2, len2)

plot(ma_1, title="Fast MA", color = green, linewidth=2, transp=0)
plot(ma_2, title="Slow MA", color = red, linewidth=2, transp=0)

longCond = na
shortCond = na
longCond := crossover(ma_1, ma_2)
shortCond := crossunder(ma_1, ma_2)

// Count your long short conditions for more control with Pyramiding

sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])

if longCond
    sectionLongs := sectionLongs + 1
    sectionShorts := 0

if shortCond
    sectionLongs := 0
    sectionShorts := sectionShorts + 1
    
// Pyramiding Inputs

pyrl = input(1, "Pyramiding")

// These check to see your signal and cross references it against the pyramiding settings above

longCondition = longCond and sectionLongs <= pyrl 
shortCondition = shortCond and sectionShorts <= pyrl 

// Get the price of the last opened long or short

last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? high[1] : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? low[1] : nz(last_open_shortCondition[1])

// Check if your last postion was a long or a short

last_longCondition = na
last_shortCondition = na
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])

in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition

// Take profit

isTPl = input(false, "Take Profit Long")
isTPs = input(false, "Take Profit Short")
tpl = input(3, "Take Profit Long %", type=float)
tps = input(30, "Take Profit Short %", type=float)
long_tp = isTPl and crossover(high, (1+(tpl/100))*last_open_longCondition) and in_longCondition  == 1
short_tp = isTPs and crossunder(low, (1-(tps/100))*last_open_shortCondition) and in_shortCondition == 1 

// Stop Loss

isSLl = input(false, "Stop Loss Long")
isSLs = input(false, "Stop Loss Short")
sl= 0.0
sl := input(3, "Stop Loss %", type=float)
long_sl = isSLl and crossunder(low, (1-(sl/100))*last_open_longCondition) and longCondition == 0 and in_longCondition == 1
short_sl = isSLs and crossover(high, (1+(sl/100))*last_open_shortCondition) and shortCondition == 0 and in_shortCondition == 1

// Create a single close for all the different closing conditions.

long_close = long_tp or long_sl ? 1 : 0
short_close = short_tp or short_sl ? 1 : 0

// Get the time of the last close

last_long_close = na
last_short_close = na
last_long_close := long_close ? time : nz(last_long_close[1])
last_short_close := short_close ? time : nz(last_short_close[1])

// Strategy entries

strategy.entry("long", strategy.long, when=longCondition == true, stop = open[1])
strategy.entry("short", strategy.short, when=shortCondition == true)
strategy.close("long", when = long_sl or long_tp)
strategy.close("short", when = short_sl or short_tp)