Größter MAE bei mehreren Geschäften

Wir haben einen Schnipsel "Größte MAE".
Es ist sehr nützlich, um zu sehen, wie sich eine Strategie mit einem einzigen Auftrag verhält.

Aus Erfahrung habe ich oft festgestellt, dass es effizienter ist, mit einem Korb von Aufträgen zu arbeiten als mit einem einzelnen Auftrag. Zum Beispiel ist es klüger, 1 % des Risikos auf einen Korb von Aufträgen zu verteilen, anstatt die vollen 1% auf einen einzelnen Auftrag.

Mit einem Korb oder Aufträgen haben Sie mehr Flexibilität, da Sie mehrere Einstiegspositionen wählen können. Sie müssen sich nicht auf eine einzige Einstiegsposition festlegen.

Wenn Sie mehrere Aufträge auf einmal eröffnen, Sie müssen die gesamte MAE aller offenen Positionen berechnen..

Diese Berechnung ist erforderlich, wenn Sie alle Positionen in dieselbe Richtung eröffnen. (keine Absicherungsposition)

Ich schlage hier zwei Schnipsel vor: 

Die erste: "BiggestMAEallTrade", gibt Ihnen die größte MAE für EIN Vertrag.  Ich habe die Kalkulation für einen Vertrag gemacht um genaue Ergebnisse zu erhalten, auch wenn die Strategie die Kontraktgröße während des In Sample Zeitraums erhöht.

Anhand dieser Ergebnisse können Sie sich ein gutes Bild machen, wenn Sie beispielsweise mit 0,1 Kontrakten arbeiten.

Paket SQ.Columns.Databanks;

import com.strategyquant.lib.L;
importieren com.strategyquant.lib.SQUtils;
import com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

import java.util.List;
import java.util.ArrayList; import java.util;
import java.util.*;
import java.lang.*;

// Modus in Frankreich von Emmanuel Evrard für die StrategyQuantX Community :)
public class BiggestMAEallTrade extends DatabankColumn
{
    public BiggestMAEallTrade()
    {
        super(L.tsq("Biggest Multiple MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Biggest Multiple MAE - ist die schlimmste Maximum Adverse Excursion aller gleichzeitig geöffneten Trades"));
    }
    
    //------------------------------------------------------------------------

    @Override
    public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
    {
        double worstMAE = -Double.MAX_VALUE;
        Date date = new Date();
        Date dateTemp = new Date();
        double Total1 = 0;
        double Size1 = 0;

        for(int i = 0; i worstMAE)
            {
                worstMAE = (Gesamt1/Auftrag.Größe);
            }
        }
        
        return -1*worstMAE;
    }
}

Die zweite: "GrößterMAEallTradePct", ergibt die größte MAE im Vergleich zu AccountBalanceDies ist interessant, um zu sehen, ob eine Strategie zu wenig oder zu viel von der Kontostand.

Wenn Sie eine 5% Maximaler Tagesverlustkönnen Sie sehen, ob Sie sich darüber oder darunter befinden.

Paket SQ.Columns.Databanks;

import com.strategyquant.lib.L;
importieren com.strategyquant.lib.SQUtils;
import com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

import java.util.List;
import java.util.ArrayList; import java.util;
import java.util.*;
import java.lang.*;

// Modus in Frankreich von Emmanuel Evrard für die StrategyQuantX Community :)
public class BiggestMAEallTradePct extends DatabankColumn
{
    public BiggestMAEallTradePct()
    {
        super(L.tsq("Biggest Multiple MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(70);
        setTooltip(L.tsq("Biggest Multiple MAE % - ist die schlechteste Maximum Adverse Excursion aller gleichzeitig offenen Trades im Vergleich zum AccountBalance"));
    }
    
    @Override
    public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
    {
        double worstMAE = -Double.MAX_VALUE;
        Date date = new Date();
        Date dateTemp = new Date();
        double Total1 = 0;
        double Gesamt2 = 0;

        for(int i = 0; i worstMAE)
            {
                schlechtesteMAE = Summe2;
            }
        }

        return -1*worstMAE;
    }
}

Wenn Sie mehrere Positionen in entgegengesetzter Richtung haben, bullish und bearish, in diesem Fall könnte es interessant sein, ein anderes Kalkül zu haben:

Ich habe die größere MAE und subtrahieren Sie die MFE der entgegengesetzten Richtung um den globalen MAE-Wert dieses größten MAE-Wertes zu erhalten.

Dies funktioniert nur, wenn die gegenläufigen Geschäfte während der größeren MAE geöffnet sind und nicht danach. Allerdings kann diese Berechnung nützlich sein.

Ich habe diese Änderungen in Schnipseln vorgenommen BiggestMAEallHedgingTrade und GrößterMAEallHedgingTradePct

Paket SQ.Columns.Databanks;

import com.strategyquant.lib.L;
importieren com.strategyquant.lib.SQUtils;
import com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

import java.util.List;
import java.util.ArrayList; import java.util;
import java.util.*;
import java.lang.*;

// Modus in Frankreich von Emmanuel Evrard für die StrategyQuantX Community :)
public class BiggestMAEallHedgingTrade extends DatabankColumn
{
    public BiggestMAEallHedgingTrade()
    {
        super(L.tsq("Biggest Multiple Hedging MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Biggest Multiple Hedging MAE - ist die schlimmste Maximum Adverse Excursion aller gleichzeitig offenen Trades"));
    }
    
    //------------------------------------------------------------------------

    @Override
    public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
    {
        double worstMAE1= -Double.MAX_VALUE;
        double worstMAE2 = -Double.MAX_VALUE;
        double BesttMFE1= -Double.MAX_VALUE;

        Date date = new Date();
        Date dateTemp = new Date();
        double Gesamt1 = 0;
        double Größe1 = 0;
        int Richtung = 0;

        for(int i = 0; i  worstMAE1)
                {
                    worstMAE1 = (Gesamt1/Auftrag.Größe);
                }
            }
        }

        Gesamt1 = 0;
        for(int i = 0; i  worstMAE2)
                {
                    worstMAE2 = (Gesamt1/Bestellung.Größe);
                }
            }
        }
        
        if (worstMAE1 >= worstMAE2)
        {
            Gesamt1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Gesamt1/Bestellung.Größe);
                    }
                }
            }

            return -1*(worstMAE1 - BesttMFE1);
        }
        else if (worstMAE2 > worstMAE1)
        {
            Gesamt1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Gesamt1/Bestellung.Größe);
                    }
                }
            }

            return -1*(worstMAE2 - BesttMFE1);
        }
        return 0;
    }
}

Paket SQ.Columns.Databanks;

import com.strategyquant.lib.L;
importieren com.strategyquant.lib.SQUtils;
import com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

import java.util.List;
import java.util.ArrayList; import java.util;
import java.util.*;
import java.lang.*;

// Modus in Frankreich von Emmanuel Evrard für die StrategyQuantX Community :)
public class BiggestMAEallHedgingTradePct extends DatabankColumn
{
    public BiggestMAEallHedgingTradePct()
    {
        super(L.tsq("Biggest Multiple Hedging MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(100);
        setTooltip(L.tsq("Biggest Multiple Hedging MAE % - ist die schlechteste maximale negative Ausdehnung aller gleichzeitig geöffneten Geschäfte im Vergleich zum Kontostand"));
    }
    
    @Override
    public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
    {
        double worstMAE1= -Double.MAX_VALUE;
        double worstMAE2 = -Double.MAX_VALUE;
        double BesttMFE1= -Double.MAX_VALUE;
        Date date = new Date();
        Date dateTemp = new Date();
        double Gesamt1 = 0;
        double Gesamt2 = 0;
        int direction = 0;

        for(int i = 0; i worstMAE1)
                {
                    schlechtesteMAE1 = Summe2;
                }
            }
        }

        Gesamt1 = 0;
        for(int i = 0; i worstMAE2)
                {
                    schlechtesteMAE2 = Summe2;
                }
            }
        }

        if (worstMAE1 >= worstMAE2)
        {
            Gesamt1 = 0;
            for(int i = 0; i BesttMFE1)
                    {
                        BesttMFE1 = Summe2;
                    }
                }
            }

            return -1*(worstMAE1 - BesttMFE1);
        }
        else if (worstMAE2 > worstMAE1)
        {
            Gesamt1 = 0;
            for(int i = 0; i BesttMFE1)
                    {
                        BesttMFE1 = Summe2;
                    }
                }
            }
            return -1*(worstMAE2 - BesttMFE1);
        }
        return 0;
    }
}