Estratégia de construção de posição dinâmica

Autora:ChaoZhang, Data: 2024-02-20 14:16:30
Tags:

Resumo

A ideia principal desta estratégia é a construção dinâmica de uma posição baseada em sinais do sistema num mercado de alta para controlar os riscos e obter um preço de entrada médio mais baixo.

Estratégia lógica

A estratégia define primeiro o capital inicial e a porcentagem de DCA. No fechamento de cada barra, ele calcula uma porcentagem ajustada com base na mudança de preço. Se o preço subir, ele reduz a porcentagem. Se o preço cair, ele aumenta a porcentagem. Isso permite adicionar à posição a preços mais baixos. Ele então calcula o tamanho da ordem com base na porcentagem ajustada e no capital restante. Em cada barra fechada, ele coloca ordens para construir a posição até que o capital inicial seja usado.

Assim, pode controlar os riscos e obter um preço de entrada médio mais baixo durante a ação de preços flutuantes.

Análise das vantagens

A estratégia apresenta as seguintes vantagens:

Pode escalar dinamicamente na posição, aumentando a alocação em quedas e diminuindo a alocação em altas para controlar os riscos.
Ele obtém um preço de entrada médio mais baixo em comparação com o preço médio, permitindo mais potencial de lucro.
Ele se encaixa em mercados de alta variação com volatilidade para melhores rácios risco-recompensa.
Permite prever o capital inicial e a percentagem de DCA para controlar o risco de dimensionamento das posições.
Fornece estatísticas sobre o preço médio de entrada e o preço médio para um julgamento claro da qualidade de entrada.

Análise de riscos

Há também alguns riscos:

Em mercados em queda, continuará a aumentar a posição, levando a grandes perdas.
Se o preço subir rapidamente, a escalação diminuirá, possivelmente perdendo grande parte do rali.
A configuração inadequada dos parâmetros também representa perigos.

Orientações de otimização

Algumas maneiras de otimizar a estratégia:

Adicione a lógica de stop loss para parar de escalar em vendas pesadas.
Adaptar dinamicamente a percentagem de DCA com base na volatilidade ou noutras métricas.
Incorporar modelos de aprendizagem de máquina para prever preços e orientar decisões de escala.
Combinar outros indicadores para identificar mudanças na estrutura do mercado para dimensionar os pontos de saída.
Adicionar regras de gestão de capital às ordens de tamanho dinâmico com base nos valores da conta.

Conclusão

Esta é uma estratégia muito prática de dimensionamento de posição dinâmica. Ajusta flexivelmente o tamanho da posição com base nas flutuações de preços para alcançar boas entradas médias em mercados de alta, ao mesmo tempo em que restringe o risco através de parâmetros configuráveis. Combinando-o com outros indicadores ou modelos pode melhorar ainda mais seu desempenho. É adequado para investidores que buscam ganhos de longo prazo.

/*backtest
start: 2024-01-20 00:00:00
end: 2024-02-19 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RWCS_LTD

//@version=5
strategy("DCA IN Calculator {RWCS}", overlay=true, pyramiding=999, default_qty_type=strategy.cash, initial_capital=10000, commission_value=0.02)

// User inputs
backtestStartDate = input(timestamp("1 Jan 2024"), 
     title="Start Date", group="Backtest Time Period",
     tooltip="This start date is in the time zone of the exchange " + 
     "where the chart's instrument trades. It doesn't use the time " + 
     "zone of the chart or of your computer.")
start_date = true
starting_capital = input.float(defval=5000, title="Starting Capital")
dca_allocation_percentage = input.int(defval=10, title="DCA Allocation Percentage")

// Calculate DCA allocation based on price change
price_change_percentage = ((close - close[1]) / close[1]) * 100
adjusted_allocation_percentage = close > close[1] ? dca_allocation_percentage - price_change_percentage : dca_allocation_percentage + price_change_percentage // If price action is negative, increase allocations
adjusted_allocation_percentage1 = dca_allocation_percentage - price_change_percentage // If price action is positive, reduce allocations

// Calculate order size based on adjusted allocation percentage
order_size = (adjusted_allocation_percentage / 100) * starting_capital

// Track remaining capital
var remaining_capital = starting_capital

// Long on the close of every bar
if true
    // Ensure the order size doesn't exceed remaining capital or adjusted allocation
    order_size := math.min(order_size, remaining_capital, adjusted_allocation_percentage / 100 * starting_capital)
    // Ensure order size is not negative
    order_size := math.max(order_size, 0)
    
    strategy.entry("DCA", strategy.long, qty = order_size)
    remaining_capital := remaining_capital - order_size

// Plot average entry price
var float total_entry_price = 0.0
var int total_signals = 0

if start_date
    total_entry_price := total_entry_price + close
    total_signals := total_signals + 1

avg_entry_price = total_entry_price / total_signals

// Calculate and plot median price
var float median_price = na

if start_date
    var float sum_prices = 0.0
    var int num_prices = 0
    
    for i = 0 to bar_index
        if (time[i] >= backtestStartDate)
            sum_prices := sum_prices + close[i]
            num_prices := num_prices + 1
    
    median_price := sum_prices / num_prices

// Reset variables at the start of each day
if (dayofweek != dayofweek[1])
    total_entry_price := 0.0
    total_signals := 0

//table colors
borders_col = color.new(color.black, 90)
top_row_col = color.new(color.gray, 90)
size = input.string(defval='Normal', options=['Tiny', 'Small', 'Normal', 'Large'], title='Table size', inline='design', group='Table Design')
table_size = size == 'Tiny' ? size.tiny : size == 'Small' ? size.small : size == 'Normal' ? size.normal : size == 'Large' ? size.large : na

var tablee = table.new(position=position.top_right, columns=2, rows=3, frame_color=borders_col, frame_width=4, border_color=borders_col, border_width=4)

table.cell(tablee, 0, 0, "Average Entry Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 0, str.tostring(avg_entry_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 1, "Median Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 1, str.tostring(median_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 2, "Remaining Capital", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 2, str.tostring(remaining_capital, '#.##'), text_color=color.white, text_size=table_size)

Mais.