Estratégia de negociação de alta frequência baseada em suporte e resistência de supertendência e indicador ADX
ChaoZhang
Visão geral
Esta estratégia usa uma linha de resistência de suporte de tendência e um indicador de ADX para realizar negociações de alta frequência. A linha de resistência de suporte de tendência é usada para determinar a tendência dos preços e emitir sinais de negociação através do cálculo dinâmico dos pontos de resistência de suporte mais recentes. O indicador de ADX é usado para determinar a força da tendência, configurando o valor de ADX como uma condição de filtragem e emitindo sinais de negociação somente quando a tendência é forte o suficiente.
Princípio da estratégia
Calcular as linhas de resistência de suporte. Usando o preço de fechamento como referência, adicione uma amplitude de ATR para cima e para baixo. Quando o preço quebra essas linhas, é considerado uma reversão de tendência.
O indicador ADX determina a força da tendência. Quando o ADX é superior ao valor definido, a tendência é considerada forte o suficiente.
A combinação de ambos emite um sinal de negociação. Apenas faça mais curto se você quebrar a resistência de suporte e o ADX for grande o suficiente.
Análise de vantagens
A estratégia tem as seguintes vantagens:
O cálculo dinâmico da linha de tendência ultra suporta a resistência, permitindo a rápida determinação da ruptura.
O indicador ADX é eficaz para filtrar cenários de não-tendência, reduzindo a negociação inválida.
O retiro e o lucro são muito bons.
Análise de Riscos
A estratégia também apresenta os seguintes riscos:
Os grandes saltos podem fazer com que a linha de tendência ultrapasse.
A definição incorreta do ADX também pode afetar o desempenho da estratégia.
As transações de alta frequência são mais caras.
Resolução:
Optimizar o hiperparamétrico e amenizar adequadamente a amplitude de ruptura.
Teste melhor os parâmetros ADX.
Reduzir adequadamente a frequência das transações.
Direção de otimização
A estratégia pode ser melhorada em:
Optimizar os parâmetros do ATR para tornar a linha de resistência de suporte mais robusta.
Teste diferentes parâmetros ADX para encontrar o melhor valor.
Acompanhar o mecanismo de parada de prejuízos para controlar os prejuízos individuais.
Resumir
Esta estratégia integra os benefícios da linha de tendência ultra e do indicador ADX, e determina o tempo de reversão da tendência com base no cálculo dinâmico da resistência, em conjunto com o indicador ADX que filtra os sinais de baixa qualidade. Após a otimização dos parâmetros e o ajuste do mecanismo, pode ser uma estratégia de alta frequência com ganhos estáveis.
/*backtest
start: 2023-02-12 00:00:00
end: 2024-02-18 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("STPP20 + ADX", overlay = true)
///////////////////////////
// SuperTrend + Pivot Point
//////////////////////////
src = input(close, title="EMA Source")
PPprd = input(defval = 2, title="Pivot Point Period", minval = 1, maxval = 50)
AtrFactor=input(defval = 5, title = "ATR Factor", minval = 1, step = 0.1)
AtrPd=input(defval = 20, title = "ATR Period", minval=1)
float ph = na
float pl = na
ph := pivothigh(PPprd, PPprd)
pl := pivotlow(PPprd, PPprd)
float center = na
center := center[1]
float lastpp = ph ? ph : pl ? pl : na
if lastpp
if na(center)
center := lastpp
else
center := (center * 2 + lastpp) / 3
Up = center - (AtrFactor * atr(AtrPd))
Dn = center + (AtrFactor * atr(AtrPd))
float TUp = na
float TDown = na
Trend = 0
TUp := close[1] > TUp[1] ? max(Up, TUp[1]) : Up
TDown := close[1] < TDown[1] ? min(Dn, TDown[1]) : Dn
Trend := close > TDown[1] ? 1: close < TUp[1]? -1: nz(Trend[1], 1)
Trailingsl = Trend == 1 ? TUp : TDown
// Lines
linecolor = Trend == 1 and nz(Trend[1]) == 1 ? color.lime : Trend == -1 and nz(Trend[1]) == -1 ? color.red : na
plot(Trailingsl, color = linecolor , linewidth = 2, title = "PP SuperTrend")
bsignalSSPP = close > Trailingsl
ssignalSSPP = close < Trailingsl
///////
// ADX
//////
lenADX = 14
th = 25
TrueRange = max(max(high-low, abs(high-nz(close[1]))), abs(low-nz(close[1])))
DirectionalMovementPlus = high-nz(high[1]) > nz(low[1])-low ? max(high-nz(high[1]), 0): 0
DirectionalMovementMinus = nz(low[1])-low > high-nz(high[1]) ? max(nz(low[1])-low, 0): 0
SmoothedTrueRange = 0.0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1])/lenADX) + TrueRange
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1])/lenADX) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = 0.0
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1])/lenADX) + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIPlus-DIMinus) / (DIPlus+DIMinus)*100
ADX = sma(DX, lenADX)
//////
// MA
/////
lenMA = 21
srcMA = input(close, title="Source")
offsetMA = input(title="Offset", type=input.integer, defval=0, minval=-500, maxval=500)
outMA = sma(srcMA, lenMA)
// Buy - Sell Entries
buy = bsignalSSPP and outMA < close and ADX > th
sell = ssignalSSPP
if (buy)
// .order // Tuned version
strategy.entry("Buy", strategy.long)
if (sell) and (strategy.position_size > 0)
strategy.order("Sell", false, when = sell)