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

Estratégia Quântica Simples de Pirâmide de Passo de Tempo

Autora:ChaoZhang, Data: 2023-12-27 17:39:40
Tags:

Resumo

Esta estratégia é uma estratégia de negociação quântica simples que utiliza pirâmide de tempo gradual. A ideia principal é abrir posições longas todos os dias em horários fixos, e definir diferentes níveis de lucro e stop loss para cada posição para realizar a tomada de lucro em lote e a perda de stop.

Princípios

A estratégia baseia-se em três lógicas fundamentais:

Pirâmide de passo no tempo

Utilize osessionTimePara definir uma janela de tempo de negociação diária, as posições longas da pirâmide são gradualmente abertas no mercado durante esta janela.
Ativos e passivos

Conjunto correspondente ao nível de lucrotakeProfite nível de stop lossstopLosspara cada posição aberta, de modo que cada posição tenha a sua própria lógica de lucro e perda de parada para realizar execuções por lotes.
Fechar todas as posições quando a janela de tempo terminar

Escolha se quer fechar todas as posições abertas durante a janela de tempo no final da janela.

Vantagens

A estratégia apresenta as seguintes vantagens:

Diversificação do risco: alocar equitativamente o capital em diferentes posições para controlar eficazmente a perda de uma única posição.
As diferentes posições têm lógicas independentes para evitar perdas de parada em massa.
Configurações flexíveis. Parâmetros personalizáveis como tempos máximos de pirâmide, janela de tempo diária, rácios de lucro/perda de parada, etc.
Lógica simples e clara, fácil de entender.

Riscos

Há também alguns riscos:

O risco de todo o capital ficar preso se todas as posições desencadearem o stop loss antes de obter lucro.
Não há limite para o capital total de posição aberta por dia. Muitas posições podem exceder a tolerância de capital se encontrar situações de mercado incomuns.
A configuração incorreta da janela de tempo pode perder as oportunidades de negociação.

Reforço

A estratégia pode ser reforçada pelos seguintes aspectos:

Adicionar condições de posição aberta baseadas em indicadores técnicos para evitar pirâmides imprudentes.
Adicionar o limite de capital total da posição aberta diária para evitar o excesso da capacidade de absorção do capital.
Estabelecer diferentes rácios take profit/stop loss para diferentes posições para obter uma tomada de lucro e uma stop loss diferenciadas.
Adicionar lógica para ligar o montante da posição ao saldo do capital.

Conclusão

Em conclusão, este é um modelo de estratégia de negociação de quantidade muito simples utilizando a metodologia de pirâmide de tempo. A lógica é simples e clara, enquanto também há alguns riscos e espaço para melhoria. Os desenvolvedores podem otimizá-lo adequadamente para torná-lo uma estratégia de quantidade relativamente estável e confiável.

/*backtest
start: 2022-12-20 00:00:00
end: 2023-12-26 00:00:00
period: 1d
basePeriod: 1h
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/
// © A3Sh

//@version=5
strategy("Simple_Pyramiding", overlay=true, pyramiding=99, initial_capital=500, default_qty_type=strategy.percent_of_equity, commission_type=strategy.commission.percent, commission_value=0.075, close_entries_rule='FIFO')

// Study of a Simple DCA strategy that opens a position every day at a specified time.
// A position is opened at the start time of the Timeframe.
// Positions exit individually when the take profit level is triggered.
// Option to activate Stop Loss and/or Position exit at the end of the Timeframe


// Backtest Window
start_time   = input(defval=timestamp("01 April 2021 20:00"), group = "Backtest Window", title="Start Time")
end_time     = input(defval=timestamp("01 Aug 2022 20:00"),  group = "Backtest Window", title="End Time")
window() => true


// Inputs
posCount     = input.int    (6,           group = "Risk",         title = "Max Amount of DCA Entries")
takeProfit   = input.float  (2.5,         group = "Risk",         title = "Take Profit %")
slSwitch     = input.bool   (true,        group = "Risk",         title = "Activate Stop Loss")
stopLoss     = input.float  (9,           group = "Risk",         title = "Stop Loss %")
sessionTime =  input("1800-1700", group = "DCA Settings", title = "DCA Order Timeframe", tooltip="Open order at the start/If ativated, close order at the end")
exitDCA     =  input.bool   (false,       group = "DCA Settings", title = "Exit DCA Entry at end of Timeframe")


// Order size based on max amount of pyramid orders
q = (strategy.equity  / posCount) / open


// Timeframe for opening and closing a DCA order
// example taken from https://stackoverflow.com/questions/69230164/pinescript-basic-question-open-a-trade-at-a-set-time-each-day
t       = time("D", sessionTime)
isStart = na(t[1]) and not na(t) or t[1] < t
isEnd   = na(t) and not na(t[1]) or t[1] < t
bgcolor(t ? color.new(color.blue,95) : na, title = " TimeFrame Color")


// Create DCA Entries
entry_price = 0.0
if isStart and window() 
    for i = 0 to strategy.opentrades
        if strategy.opentrades == i
            entry_price := close
            entry_id = "PE_" + str.tostring(i + 1) 
            strategy.entry(id = entry_id, direction=strategy.long, limit=entry_price, qty=q)
        if strategy.opentrades == posCount
            break
            
 
//Exit DCA Entries when take profit or stop loss is triggered
if strategy.opentrades > 0 and window() 
    for i = 0 to strategy.opentrades 
        exit_from = "PE_" + str.tostring(i + 1)
        exit_id = "Exit_" + str.tostring(i + 1)
        strategy.exit(id= exit_id, from_entry= exit_from, profit = close * takeProfit / 100 / syminfo.mintick, loss = slSwitch ? close * stopLoss /100 / syminfo.mintick :na)
        

//Exit DCA Entries at end of DCA Timeframe
if strategy.opentrades > 0 and exitDCA and isEnd and window() 
    for i = 0 to strategy.opentrades 
        exit_from = "PE_" + str.tostring(i + 1)
        exit_id = "Exit_" + str.tostring(i + 1)
        strategy.exit(id= exit_id, from_entry= exit_from, stop = close)

Mais.