Tagliato per consentire un massimo di operazioni di simulazione per ogni strumento

Oggi c'è la possibilità di testare le operazioni massime al giorno, ma non sono sicuro che funzioni come detto, dato che anche se si imposta 1 operazione al giorno, a volte ci sono 3 operazioni al giorno. Quando si costruisce un portafoglio la correlazione è sempre un problema sullo stesso strumento. Le operazioni vengono effettuate molto vicino l'una all'altra ma con uscite diverse, il che fa pensare a QA che non siano correlate, ma in realtà sono molto correlate, soprattutto durante i periodi di perdita. Esiste un modo per evitare di effettuare più di un'operazione simultanea sullo stesso strumento utilizzando un copiatore, ma non esiste una funzione "what if" in QA per verificare quale sarebbe la performance.

Spero che qualcuno possa aiutarmi con questa funzione, poiché ritengo che possa essere una caratteristica in grado di ridurre notevolmente il drawdown dei portafogli di grandi dimensioni. L'ho testata su un conto live e ho notato che la curva EQ diventa molto più regolare, il drawdown molto più ridotto e il profitto migliore rispetto al conto in cui non viene utilizzata.

Ecco il codice per limitare il numero di operazioni aperte in una sola volta nell'Analisi What-if. Non sono un codificatore, quindi non è il modo più efficiente né il migliore. Ma è un modo che funziona, quindi lo condivido nel caso in cui possa essere d'aiuto a qualcuno:

 

pacchetto com.strategyquant.extend.WhatIf;

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

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

classe pubblica TakeMaxTradesAtOneTime estende WhatIf
{

pubblico TakeMaxTradesAtOneTime()
{
setName(L.t("Effettua il massimo di operazioni in una sola volta"));

addIntParameter("Trades", L.t("Trades"), 1, 1, Integer.MAX_VALUE, 1);
setFormatedName(L.t("Effettua un massimo di operazioni {Trades} in una sola volta"));
}

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();)
{
SQOrder order = i.next();

if(order.isBalanceOrder())
continuare;
long closedatetime = order.CloseTime;

se (FirstRun == 0)
{
Closedatetime[0] = closedatetime;
FirstRun = 1;
}
int count = Closedatetime.length;
se (numero <= scambi)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1);
Closedatetime[Closedatetime.length - 1] = closedatetime;
}
altro
{
Arrays.sort(Closedatetime);
long opendatetime = order.OpenTime;
per (int j = 0; j < Closedatetime.length; j++)
{
se (opendatetime > Closedatetime[j])
Closedatetime = removeElement(Closedatetime,j);
}
count = Closedatetime.length;
se (numero <= scambi)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1);
Closedatetime[Closedatetime.length - 1] = closedatetime;
}
altro
i.remove();
}
}
}

private long[] removeElement(long[] arr, int index)
{
long[] anotherArray = new long[arr.length - 1];
per (int l = 0, k = 0; l < arr.length; l++)
{
se (l == indice)
continuare;
anotherArray[k] = arr[l];
k++;
}
restituire anotherArray;
}
}