Estratégia de Padrão ABCD Momentum
ChaoZhang
Visão geral
Esta estratégia usa o indicador Williams Fractal para identificar os altos e baixos dos preços e, em combinação com a forma ABCD, julga a direção da tendência, fazendo uma entrada após a confirmação da tendência para obter lucros de tendências de curta duração.
Princípio da estratégia
O indicador Williams Fractal é usado para identificar os pontos altos e baixos dos preços, sendo o ABCD do mercado de ativos em alta ou o ABCD do mercado de ativos em baixa, de acordo com diferentes formas.
Critérios de avaliação da forma ABCD:
A distância entre AB e CD é próxima, a distância entre BC e CD corresponde a um determinado requisito de proporção (entre 0,382-0,886 e 1,13-2,618).
D abaixo de C é um mercado de touros, D acima de C é um mercado de ursos.
A função barssince determina a distância fractal de uma direção anterior à direção mais recente para determinar a direção da tendência geral atual.
Quando se identifica a forma ABCD, é possível entrar em over/under e definir stop loss e stop loss, seguindo a tendência de linha curta.
Análise de vantagens estratégicas
O uso do indicador Williams Fractal auxiliar ao julgamento permite uma identificação mais precisa dos pontos de inflexão.
O critério de avaliação da forma ABCD é simples, confiável e fácil de programar.
Combinando a função barssince para determinar a direção da grande tendência, pode-se efetivamente reduzir os prejuízos causados por falsas rupturas.
A configuração de um stop loss para traçar uma curta linha de tendência pode traçar uma curta linha de tendência.
Análise de risco estratégico
O Williams Fractal está atrasado e pode ter perdido o ponto de viragem, causando prejuízos.
Existem várias formas de ABCD sobrepostas na linha curta central, o que pode causar erros de identificação.
Quando os grandes tendências são imprecisos, as transações de linha curta e média são facilmente encurraladas.
A configuração de parada de danos é pequena demais para ser atingida, e a configuração de parada de danos é grande demais para ser atingida, e a configuração de parada de danos é grande demais para ser atingida.
Métodos de optimização:
Pode-se experimentar o uso de outros indicadores para auxiliar o julgamento, procurando formas mais eficazes de identificar os pontos de inflexão.
Optimizar os parâmetros da forma ABCD para tornar o julgamento mais rigoroso e confiável.
Otimizar os métodos de avaliação das grandes tendências para evitar erros de avaliação das grandes tendências.
Teste diferentes proporções de stop loss para encontrar o melhor ponto de stop loss.
Direção de otimização da estratégia
Pode-se tentar usar outros indicadores como MACD, KDJ e outros para auxiliar na determinação de tendências, procurando um momento de entrada mais preciso.
Os parâmetros podem ser otimizados de acordo com os diferentes ciclos de diferentes variedades para encontrar o ponto de parada de perda mais adequado para o ciclo da variedade.
Pode-se tirar o ciclo inteiro de otimização de acordo com as mudanças do mercado, procurando o melhor conjunto de parâmetros.
Pode ser combinado com indicadores como a linha de equilíbrio para filtrar os sinais de entrada, aumentando a estabilidade da estratégia.
Algoritmos de aprendizagem de máquina podem ser introduzidos para usar mais modelos de treinamento de dados para melhorar a precisão de identificação.
Resumir
A estratégia é clara e confiável, usando o indicador Williams Fractal e a direção da tendência de linha curta no julgamento da forma ABCD, em combinação com o filtro de tendência e a configuração do stop loss para acompanhar a tendência. Há muito espaço para otimização da estratégia, que pode ser melhorada em termos de sinal de entrada, otimização de parâmetros e julgamento de tendência, para que a estratégia seja mais adequada para diferentes ambientes de mercado.
/*backtest
start: 2023-09-16 00:00:00
end: 2023-09-23 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// @version=4
// @author=Daveatt - BEST
// ABCD Pattern Strat
StrategyName = "BEST ABCD Pattern Strategy"
ShortStrategyName = "BEST ABCD Pattern Strategy"
// strategy(title=StrategyName, shorttitle=ShortStrategyName, overlay=true,
// pyramiding=2, default_qty_value=100, precision=7, currency=currency.USD,
// commission_value=0.2,commission_type=strategy.commission.percent, initial_capital=1000000,
// default_qty_type=strategy.fixed)
filterBW = input(false, title="filter Bill Williams Fractals?")
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////// UTILITIES ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// ||-----------------------------------------------------------------------------------------------------||
// ||--- Fractal Recognition Functions: ---------------------------------------------------------------||
isRegularFractal(mode, _high, _low) =>
ret = mode == 1 ? _high[4] < _high[3] and _high[3] < _high[2] and _high[2] > _high[1] and _high[1] > _high[0] :
mode == -1 ? _low[4] > _low[3] and _low[3] > _low[2] and _low[2] < _low[1] and _low[1] < _low[0] : false
isBWFractal(mode, _high, _low) =>
ret = mode == 1 ? _high[4] < _high[2] and _high[3] <= _high[2] and _high[2] >= _high[1] and _high[2] > _high[0] :
mode == -1 ? _low[4] > _low[2] and _low[3] >= _low[2] and _low[2] <= _low[1] and _low[2] < _low[0] : false
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
////////////////////////////// ABCD PATTERN ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
f_abcd()=>
_r = timeframe.period
_g = barmerge.gaps_off
_l = barmerge.lookahead_on
_high = high
_low = low
filteredtopf = filterBW ? isRegularFractal(1, _high, _low) : isBWFractal(1, _high, _low)
filteredbotf = filterBW ? isRegularFractal(-1, _high, _low) : isBWFractal(-1, _high, _low)
// ||--- ZigZag:
istop = filteredtopf
isbot = filteredbotf
topcount = barssince(istop)
botcount = barssince(isbot)
zigzag = (istop and topcount[1] > botcount[1] ? _high[2] :
isbot and topcount[1] < botcount[1] ? _low[2] : na)
x = valuewhen(zigzag, zigzag, 4)
a = valuewhen(zigzag, zigzag, 3)
b = valuewhen(zigzag, zigzag, 2)
c = valuewhen(zigzag, zigzag, 1)
d = valuewhen(zigzag, zigzag, 0)
xab = (abs(b-a)/abs(x-a))
xad = (abs(a-d)/abs(x-a))
abc = (abs(b-c)/abs(a-b))
bcd = (abs(c-d)/abs(b-c))
// ABCD Part
_abc = abc >= 0.382 and abc <= 0.886
_bcd = bcd >= 1.13 and bcd <= 2.618
_bull_abcd = _abc and _bcd and d < c
_bear_abcd = _abc and _bcd and d > c
_bull = _bull_abcd and not _bull_abcd[1]
_bear = _bear_abcd and not _bear_abcd[1]
[_bull, _bear, zigzag]
lapos_x = timenow + round(change(time)*12)
[isLong, isShort, zigzag] = f_abcd()
plot(zigzag, title= 'ZigZag', color=color.black, offset=-2)
plotshape(isLong, style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), size=size.normal, text="ABCD", textcolor=color.white)
plotshape(isShort, style=shape.labeldown, location=location.abovebar, color=color.new(color.maroon, 0), size=size.normal, text="ABCD", textcolor=color.white)
long_entry_price = valuewhen(isLong, close, 0)
short_entry_price = valuewhen(isShort, close, 0)
sinceNUP = barssince(isLong)
sinceNDN = barssince(isShort)
buy_trend = sinceNDN > sinceNUP
sell_trend = sinceNDN < sinceNUP
//////////////////////////
//* Profit Component *//
//////////////////////////
//////////////////////////// MinTick ///////////////////////////
fx_pips_value = syminfo.type == "forex" ? syminfo.mintick*10 : 1
input_tp_pips = input(100, "Backtest Profit Goal (in USD)",minval=0)*fx_pips_value
input_sl_pips = input(20, "Backtest STOP Goal (in USD)",minval=0)*fx_pips_value
tp = buy_trend? long_entry_price + input_tp_pips : short_entry_price - input_tp_pips
sl = buy_trend? long_entry_price - input_sl_pips : short_entry_price + input_sl_pips
plot_tp = buy_trend and high[1] <= tp ? tp : sell_trend and low[1] <= tp ? tp : na
plot_sl = buy_trend and low[1] >= sl ? sl : sell_trend and high[1] >= sl ? sl : na
plot(plot_tp, title="TP", style=plot.style_circles, linewidth=3, color=color.blue)
plot(plot_sl, title="SL", style=plot.style_circles, linewidth=3, color=color.red)
longClose = isShort
shortClose = isLong
strategy.entry("Long", 1, when=isLong)
// strategy.close("Long", when=longClose )
strategy.exit("XL","Long", limit=tp, when=buy_trend, stop=sl)
strategy.entry("Short", 0, when=isShort)
// strategy.close("Short", when=shortClose )
strategy.exit("XS","Short", when=sell_trend, limit=tp, stop=sl)