Coupé pour le cas où l'on autoriserait un nombre maximum de transactions simultanées par instrument.

Aujourd'hui, il est possible de tester le nombre maximum de transactions par jour, mais je ne suis pas sûr que cela fonctionne comme prévu, car même si l'on règle sur 1 transaction par jour, il y a parfois 3 transactions par jour. Lors de la construction d'un portefeuille, la corrélation est toujours un problème sur le même instrument. Les transactions sont prises très près les unes des autres mais avec des sorties différentes, ce qui fait penser à QA qu'elles ne sont pas corrélées mais elles sont en fait très corrélées, en particulier pendant les périodes de perte. Il existe des moyens d'éviter de prendre plus d'une transaction simultanément sur le même instrument en utilisant un copieur, mais il n'y a pas de fonction de simulation dans QA pour vérifier quelle serait la performance.

J'espère que quelqu'un pourra m'aider avec cette fonction car je pense qu'elle peut réduire considérablement le drawdown des grands portefeuilles. J'ai testé cette fonction sur un compte réel et ce que je peux voir c'est que la courbe EQ devient beaucoup plus lisse et le drawdown beaucoup plus petit et le profit meilleur que sur le compte où elle n'est pas utilisée.

Voici un code permettant de limiter le nombre de transactions ouvertes en même temps dans l'analyse d'hypothèses. Je ne suis pas un codeur, ce n'est donc pas la méthode la plus efficace ni la meilleure. Mais c'est une méthode qui fonctionne, alors je la partage au cas où elle aiderait quelqu'un :

 

package com.strategyquant.extend.WhatIf ;

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

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

public class TakeMaxTradesAtOneTime extends WhatIf
{

public TakeMaxTradesAtOneTime()
{
setName(L.t("Prendre le maximum de transactions en une seule fois")) ;

addIntParameter("Trades", L.t("Trades"), 1, 1, Integer.MAX_VALUE, 1) ;
setFormatedName(L.t("Prendre un maximum de {Trades} en une seule fois")) ;
}

public void filter(SQOrderList originalOrders) jette des exceptions
{
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())
continuer ;
long closedatetime = order.CloseTime ;

si (FirstRun == 0)
{
Closedatetime[0] = closedatetime ;
FirstRun = 1 ;
}
int count = Closedatetime.length ;
if (count <= trades)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1) ;
Closedatetime[Closedatetime.length - 1] = closedatetime ;
}
autre
{
Arrays.sort(Closedatetime) ;
long opendatetime = order.OpenTime ;
for (int j = 0 ; j < Closedatetime.length ; j++)
{
if (opendatetime > Closedatetime[j])
Closedatetime = removeElement(Closedatetime,j) ;
}
count = Closedatetime.length ;
if (count <= trades)
{
Closedatetime = Arrays.copyOf(Closedatetime, Closedatetime.length + 1) ;
Closedatetime[Closedatetime.length - 1] = closedatetime ;
}
autre
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++)
{
si (l == index)
continuer ;
anotherArray[k] = arr[l] ;
k++ ;
}
return anotherArray ;
}
}