O recurso está a ser carregado... Carregamento...

Estratégia de fuga dupla

Autora:ChaoZhang, Data: 2023-11-03 17:16:02
Tags:

Resumo

Esta estratégia utiliza bandas de Bollinger para identificar pontos de ruptura para transações longas e curtas, combinadas com o indicador ADX para filtrar condições desfavoráveis de mercado de baixa volatilidade, a fim de seguir as tendências.

Estratégia lógica

A estratégia baseia-se principalmente no indicador Bollinger Bands para determinar a direção longa ou curta. A faixa média das Bollinger Bands é a média móvel de N dias do preço de fechamento, e a largura da faixa é calculada usando desvio padrão.

Para evitar breakouts inválidos e negociações errôneas em mercados agitados, a estratégia incorpora o indicador ADX para filtrar condições de mercado de baixa volatilidade. Os sinais de negociação são gerados apenas quando o valor do ADX está abaixo de um limiar. Quando o ADX ultrapassa o limiar, todas as posições são fechadas para esperar as condições de tendência.

A estratégia também define stop loss e take profit para negociações abertas. Especificamente, após a abertura de uma posição, o preço mais baixo e o preço mais alto dos N dias anteriores são registrados como os níveis de stop loss e take profit para essa direção. Isso permite bloquear os lucros enquanto reduz as perdas de reversões.

A partir da lógica do código, a estratégia primeiro calcula as Bandas de Bollinger e os parâmetros do ADX. Em seguida, verifica se o preço quebra a faixa superior ou inferior das Bandas e se o ADX está abaixo do limiar, para gerar sinais de negociação.

Análise das vantagens

As bandas de Bollinger oferecem sinais claros de ruptura para captar oportunidades de tendência
Filtro ADX evita negociação Mercados agitados sem tendências claras
Stop loss controla efetivamente a perda de uma única operação
A retenção de lucros se bloqueia na maioria dos lucros

Análise de riscos

As rupturas podem ser falsas sem considerar o volume
O filtro ADX também pode perder oportunidades de tendências
Parar de perder e tirar lucro muito perto pode ser parado fora
Mal ajuste dos parâmetros afeta o desempenho da estratégia

Considere a combinação com outros indicadores para confirmar a ruptura com o volume; otimizar o filtro ADX usando inclinação para identificar mudanças de tendência; ampliar a faixa de stop loss e take profit para evitar uma saída prematura.

Orientações para melhorias

Otimizar o comprimento das bandas de Bollinger para obter melhores resultados de ruptura
Filtro ADX de sintonização fina para equilibrar a precisão da tendência e sinais falsos
Adicionar outros indicadores para confirmar a validade da ruptura
Otimizar o intervalo de stop loss para evitar sensibilidade excessiva
Ampliar a gama de lucros para garantir mais lucros

Conclusão

A estratégia tem uma lógica clara e simples, usando Bandas de Bollinger para sinais de ruptura óbvios, filtrados pelo ADX para condições de tendência, para capturar oportunidades de tendência.

/*backtest
start: 2023-10-26 00:00:00
end: 2023-11-02 00:00:00
period: 1m
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/
// © tweakerID

// This strategy uses Bollinger Bands to buy when the price 
// crosses over the lower band and sell when it crosses down
// the upper band. It only takes trades when the ADX is 
// below a certain level, and exits all trades when it's above it.

//@version=4
strategy("BB + ADX Strategy", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_value = 0.04, initial_capital=100)

//Inputs
i_reverse=input(false, title="Reverse Trades")
i_ADXClose=input(true, title="ADX Close")
i_SL=input(false, title="Use Swing Lo/Hi Stop Loss & Take Profit")
i_SwingLookback=input(20, title="Swing Lo/Hi Lookback")
i_SLExpander=input(defval=0, step=.5, title="SL Expander")
i_TPExpander=input(defval=0, step=.5, title="TP Expander")

//ADX Calculations
adxlen = input(14, title="ADX Smoothing")
dilen = input(20, title="DI Length")
dirmov(len) =>
	up = change(high)
	down = -change(low)
	plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
	minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
	truerange = rma(tr, len)
	plus = fixnan(100 * rma(plusDM, len) / truerange)
	minus = fixnan(100 * rma(minusDM, len) / truerange)
	[plus, minus]
adx(dilen, adxlen) =>
	[plus, minus] = dirmov(dilen)
	sum = plus + minus
	adx = 100 * rma(abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
sig = adx(dilen, adxlen)
adxlevel=input(30, step=5)

//BB Calculations
BBCALC=input(false, title="-----------BB Inputs-----------")

length = input(20, minval=1)
mult = input(2.0, minval=0.001, maxval=50)
MAlen=input(defval=9)
source = close
basis = sma(source, length)
dev = mult * stdev(source, length)
upper = basis + dev
lower = basis - dev

//Entry Logic
BUY = crossover(source, lower) and sig < adxlevel
SELL = crossunder(source, upper) and sig < adxlevel

//SL & TP Calculations
SwingLow=lowest(i_SwingLookback)
SwingHigh=highest(i_SwingLookback)
bought=strategy.position_size != strategy.position_size[1]
LSL=valuewhen(bought, SwingLow, 0)-((valuewhen(bought, atr(14), 0))*i_SLExpander)
SSL=valuewhen(bought, SwingHigh, 0)+((valuewhen(bought, atr(14), 0))*i_SLExpander)
lTP=strategy.position_avg_price + (strategy.position_avg_price-(valuewhen(bought, SwingLow, 0))+((valuewhen(bought, atr(14), 0))*i_TPExpander))
sTP=strategy.position_avg_price - (valuewhen(bought, SwingHigh, 0)-strategy.position_avg_price)-((valuewhen(bought, atr(14), 0))*i_TPExpander)
islong=strategy.position_size > 0
isshort=strategy.position_size < 0
SL= islong ? LSL : isshort ? SSL : na
TP= islong ? lTP : isshort ? sTP : na

//Entries
strategy.entry("long", long=i_reverse?false:true, when=BUY)
strategy.entry("short", long=i_reverse?true:false, when=SELL)

//EXITS
if i_ADXClose
    strategy.close_all(when=sig > adxlevel)
if i_SL
    strategy.exit("longexit", "long", stop=SL, limit=TP)
    strategy.exit("shortexit", "short", stop=SL, limit=TP)

//Plots	
plot(i_SL ? SL : na, color=color.red, style=plot.style_cross, title="SL")
plot(i_SL ? TP : na, color=color.green, style=plot.style_cross, title="TP")
plot(upper)
plot(lower)

Mais.