Corte para o tipo de instrumento que permite o máximo de simultâneos de negócios por instrumento

Hoje existe a possibilidade de testar o máximo de negociações por dia, mas não tenho certeza de que funcione como foi dito, pois mesmo que você defina 1 negociação por dia, às vezes há 3 negociações por dia. Ao criar um portfólio, a correlação é sempre um problema no mesmo instrumento. As negociações são feitas muito próximas umas das outras, mas com saídas diferentes, o que faz com que o QA pense que elas não estão correlacionadas, mas, na verdade, estão muito correlacionadas, especialmente durante os períodos de perda. Há maneiras de evitar a realização simultânea de mais de uma negociação no mesmo instrumento usando uma copiadora, mas não há uma função "e se" no QA para verificar qual seria o desempenho.

Espero que alguém possa ajudar com essa função, pois acho que ela pode ser um recurso capaz de reduzir bastante o drawdown de portfólios grandes. Tenho testado essa função em uma conta ativa e o que posso ver é que a curva de EQ se torna muito mais suave, o rebaixamento é muito menor e o lucro é melhor do que na conta em que ela não é usada.

Aqui está o código para limitar o número de negociações abertas de uma só vez na análise de variações hipotéticas. Não sou programador, portanto, não é a maneira mais eficiente nem a melhor. Mas é uma forma que funciona, portanto, compartilho-a caso ajude alguém:

 

pacote com.strategyquant.extend.WhatIf;

importar java.util.Collections;
importar java.util.Date;
importar java.util.Iterator;
importar java.util.Arrays;

import com.strategyquant.lib.comparators.OrderComparatorByOpenTime;
import com.strategyquant.lib.language.L;
import com.strategyquant.lib.results.SQOrder;
importar com.strategyquant.lib.results.SQOrderList;
importar com.strategyquant.lib.snippets.WhatIf;
import com.strategyquant.lib.time.SQTime;

public class TakeMaxTradesAtOneTime extends WhatIf
{

public TakeMaxTradesAtOneTime()
{
setName(L.t("Take maximum trades at one time"));

addIntParameter("Trades", L.t("Trades"), 1, 1, Integer.MAX_VALUE, 1);
setFormatedName(L.t("Take maximum {Trades} trades at one time"));
}

public void filter(SQOrderList originalOrders) throws Exception
{
int trades = getIntParameterValue("Trades");
long[] Closedatetime = new long[1];
int FirstRun = 0;

Collections.sort(originalOrders, new OrderComparatorByOpenTime());

for(Iterator i = originalOrders.listIterator(); i.hasNext();)
{
Pedido SQOrder = i.next();

Se (order.isBalanceOrder())
continuar;
long closedatetime = order.CloseTime;

Se (FirstRun == 0)
{
Closedatetime[0] = closedatetime;
FirstRun = 1;
}
int count = Closedatetime.length;
Se (count <= trades)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1);
Closedatetime[Closedatetime.length - 1] = closedatetime;
}
mais
{
Arrays.sort(Closedatetime);
long opendatetime = order.OpenTime;
for (int j = 0; j < Closedatetime.length; j++)
{
Se (opendatetime > Closedatetime[j])
Closedatetime = removeElement(Closedatetime,j);
}
count = Closedatetime.length;
Se (count <= trades)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1);
Closedatetime[Closedatetime.length - 1] = closedatetime;
}
mais
i.remove();
}
}
}

private long[] removeElement(long[] arr, int index)
{
long[] anotherArray = new long[arr.length - 1];
for (int l = 0, k = 0; l < arr.length; l++)
{
Se (l == índice)
continuar;
anotherArray[k] = arr[l];
k++;
}
return anotherArray;
}
}