
A estratégia de negociação de canais de flutuação de Dongjian julga a tendência atual dos preços por meio do cálculo de canais de preços mais altos e mais baixos em um determinado período e realiza negociações longas e curtas em combinação com canais de ruptura. A estratégia é adequada para ações e moedas digitais com alta volatilidade.
A estratégia constrói um canal através do cálculo do pcmax máximo e do pcmin mínimo do ciclo last (history). O método de cálculo do canal para cima e para baixo é:
Empilhamento h = pcmax - (pcmax - pcmin) * (100 - percentDev)/100
Subtração de y = pcmin + (pcmax - pcmin) * percentDev/100
A pesquisa foi publicada no site da CNN, onde a pesquisa foi publicada.
Quando o preço se move para cima, gera um sinal longo; quando o preço se move para baixo, gera um sinal curto.
O processo de determinação de um sinal de negociação específico é o seguinte:
boundup = high > yh para determinar se a rota foi quebrada
bounddn = low < yl Determinação de quebra
upsign = sma(bounddn, 2) == 1 A mediana debounddn determina que a descida é contínua
dnsign = sma(boundup, 2) == 1 A mediana de umboundup determina que a travessia continua
Exitup = dnsign Bateu a linha e gerou um sinal de estabilidade
exitdn = upsign Bateu a rota para baixo e gerou um sinal de equilíbrio
if upsign quebra a faixa de descida e gera um sinal multiplo
if dnsign quebrou a pista e gerou um sinal de vazio
A estratégia também estabelece o horário de início da negociação para evitar posições desnecessárias durante a noite.
O uso do canal de Dongxian para determinar tendências é mais eficiente
A partir de agora, você pode fazer o mesmo com os dois sinais de compra e venda.
Filtragem de linha uniforme para julgar sinais e evitar transações erradas
Definição opcional de Stop Loss e controle de risco
Configure o horário de início e fim das negociações para evitar o risco de posições durante a noite
O canal Dongjian é sensível aos parâmetros history e percentDev, e precisa de parâmetros otimizados para adaptar-se a diferentes variedades
Sinais errados podem ocorrer em situações de tremores
O que pode afetar os lucros no disco rígido sem considerar os fatores de gestão de encomendas
Risco de excesso de posições em ativos físicos sem considerar o gerenciamento de posições
O capital de transação deve ser razoavelmente configurado no disco rígido sem considerar o gerenciamento de fundos
Parâmetros optimizados de history e percentDev para melhor adaptação a diferentes variedades
Aumento de filtros para evitar sinais errados em situações de tremores
Adicionar módulo de gerenciamento de posições para controlar a proporção de capital ocupado por uma única posição
Adição do módulo de gestão de fundos, limitando a percentagem de capital ocupado na posição total
Adição de função de gerenciamento de pedidos para otimizar a forma como os pedidos são feitos
A estratégia de negociação de canal de flutuação de Dongjian é uma estratégia de negociação de tendências e sinais de negociação através de uma ruptura de canal, com uma melhor medição de retorno e capacidade de negociação bidirecional. Mas a estratégia também possui alguns riscos, que necessitam de otimização de parâmetros, filtros, gerenciamento de posição, gerenciamento de fundos e gerenciamento de pedidos para obter lucro estável no mercado.
/*backtest
start: 2023-10-31 00:00:00
end: 2023-11-07 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
////////////////////////////////////////////////////////////
// Copyright by AlexInc v1.0 02/07/2018 @aav_1980
// PriceChannel strategy
// If you find this script helpful, you can also help me by sending donation to
// BTC 16d9vgFvCmXpLf8FiKY6zsy6pauaCyFnzS
// LTC LQ5emyqNRjdRMqHPHEqREgryUJqmvYhffM
////////////////////////////////////////////////////////////
//@version=3
strategy("AlexInc PriceChannel Str", overlay=false)
history = input(20)
percentDev = input(13)
capital = input(100)
needlong = input(true, defval = true, title = "Long")
needshort = input(true, defval = true, title = "Short")
usestoploss = input(true, defval = true, title = "Stop Loss")
stoplossmult = input(3.8, defval = 3.8, minval = 1, maxval = 10, title = "Stop loss multiplicator")
fromyear = input(2018, defval = 2018, minval = 1900, maxval = 2100, title = "From Year")
toyear = input(2100, defval = 2100, minval = 1900, maxval = 2100, title = "To Year")
frommonth = input(01, defval = 01, minval = 01, maxval = 12, title = "From Month")
tomonth = input(12, defval = 12, minval = 01, maxval = 12, title = "To Month")
fromday = input(01, defval = 01, minval = 01, maxval = 31, title = "From day")
today = input(31, defval = 31, minval = 01, maxval = 31, title = "To day")
bodymin = min( open, close)
bodymax = max(open, close)
pcmax = highest(bodymax, history)
pcmin = lowest(bodymin, history)
yh = ((pcmax - pcmin) / 100 * (100 - percentDev)) + pcmin
yl = ((pcmax - pcmin) / 100 * percentDev) + pcmin
plot(pcmax)
plot(pcmin)
plot(yh)
plot(yl)
//1
bounddn = low < yl ? 1 : 0
boundup = high > yh ? 1 : 0
upsign = sma(bounddn, 2) == 1
dnsign = sma(boundup, 2) == 1
//2
//upsign = crossover(bodymin, yl)
//dnsign = crossunder(bodymax , yh)
exitup = dnsign
exitdn = upsign
lot = strategy.equity / close * capital / 100
xATR = atr(history)
nLoss = usestoploss ? stoplossmult * xATR : na
stop_level_long = 0.0
stop_level_long := nz(stop_level_long[1])
stop_level_short = 0.0
stop_level_short := nz(stop_level_short[1])
pos = strategy.position_size
if pos >0 and pos[1] <= 0 //crossover(pos, 0.5)
stop_level_long = strategy.position_avg_price - nLoss
if pos < 0 and pos[1] >= 0 //crossunder(pos, -0.5)
stop_level_short = strategy.position_avg_price + nLoss
if pos == 0
stop_level_long = bodymin - nLoss
stop_level_short = bodymax + nLoss
//plot(bodymax + nLoss, color=red)
//plot(bodymin - nLoss, color=red)
plot(stop_level_long, color=red)
plot(stop_level_short, color=red)
if upsign
strategy.entry("Long", strategy.long, needlong == false ? 0 : lot)
if dnsign
strategy.entry("Short", strategy.short, needshort == false ? 0 : na)
if true
strategy.close_all()
//if strategy.position_size != 0
// strategy.exit("Exit Long", from_entry = "Long", stop = stop_level_long)
// strategy.exit("Exit Short", from_entry = "Short", stop = stop_level_short)