O maior MAE em múltiplos comércios

Temos um trecho "Maior MAE“.
É muito útil ver como uma estratégia com uma única ordem se comporta.

Por experiência, percebi muitas vezes que é mais eficiente trabalhar com uma cesta de pedidos em vez de um único pedido. Por exemplo, é mais sábio espalhar 1 % de risco em uma cesta de pedidos, em vez do 1% completo em um único pedido.

Com uma cesta ou pedidos, você tem mais flexibilidade, pois pode escolher várias posições de entrada. Você não precisa identificar sua única posição de entrada.

Se você abrir vários pedidos de uma só vez, você tem que calcular o MAE total de todas as posições em aberto.

Este cálculo é necessário se você abrir todas as posições na mesma direção. (sem posição de cobertura)

Eu proponho aqui dois trechos: 

A primeira: " ".BiggestMAEallTrade", está lhe dando o maior MAE para UM contrato.  Eu fiz o cálculo para um contrato para ter resultados precisos mesmo que a estratégia aumente o tamanho do contrato durante o período de In Sample.

A partir deste resultado, você tem uma boa idéia, se você trabalha com tamanho de contrato 0,1, por exemplo.

pacote SQ.Colunas.Bancos de dados;

importação com.strategyquant.lib.L;
import com.strategyquant.lib.SQUtils;
Importar com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

importação java.util.list;
importação java.util.arrayList;
importação de java.util.*;
importação de java.lang.*;

// Mode na França por Emmanuel Evrard para a StrategyQuantX Community :)
classe pública BiggestMAEallTrade estende Banco de DadosColuna
{
    público BiggestMAEallTrade()
    {
        super(L.tsq("Biggest Multiple MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Biggest Multiple MAE - is the worst Maximum Adverse Excursion of all trades open at once"));
    }
    
    //------------------------------------------------------------------------

    @Override
    duplo cálculo público(SQStats stats, StatsTypeCombinação, OrderList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) lança Exceção
    {
        duplo piorMAE = -Double.MAX_VALUE;
        Data = nova Data();
        Data DataTemp = nova Data();
        duplo Total1 = 0;
        duplo Tamanho1 = 0;

        for(int i = 0; i piorMAE)
            {
                piorMAE = (Total1/ordem.Tamanho);
            }
        }
        
        retornar -1*worstMAE;
    }
}

A segunda : "BiggestMAEallTradePct", está dando o maior MAE em comparação com AccountBalanceIsto é interessante para ver se uma estratégia não usa o suficiente ou precisa muito do Saldo da conta.

Se você tiver um 5% Perda máxima diáriaVocê pode ver se você está acima ou abaixo dele.

pacote SQ.Colunas.Bancos de dados;

importação com.strategyquant.lib.L;
import com.strategyquant.lib.SQUtils;
Importar com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

importação java.util.list;
importação java.util.arrayList;
importação de java.util.*;
importação de java.lang.*;

// Mode na França por Emmanuel Evrard para a StrategyQuantX Community :)
classe pública BiggestMAEallTradePct estende Banco de DadosColuna
{
    público BiggestMAEallTradePct()
    {
        super(L.tsq("Biggest Multiple MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(70);
        setTooltip(L.tsq("Biggest Multiple MAE % - é a pior Excursão Máxima Adversa de todas as operações abertas de uma só vez em comparação com AccountBalance")));
    }
    
    @Override
    duplo cálculo público(SQStats stats, StatsTypeCombinação, OrderList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) lança Exceção
    {
        duplo piorMAE = -Double.MAX_VALUE;
        Data = nova Data();
        Data DataTemp = nova Data();
        duplo Total1 = 0;
        o dobro Total2 = 0;

        for(int i = 0; i piorMAE)
            {
                piorMAE = Total2;
            }
        }

        retornar -1*worstMAE;
    }
}

Se você tem múltiplas posições em direção oposta, em alta e em baixa, neste caso, pode ser interessante ter um cálculo diferente:

Eu tomei a MAE maior e subtrair a MFE da direção oposta para obter o MAE global deste maior MAE.

Isto só funciona se as negociações opostas estiverem abertas durante o MAE maior e não depois. Entretanto, este cálculo pode ser útil.

Eu fiz estas modificações em trechos BiggestMAEallHedgingTrade e BiggestMAEallHedgingTradePct

pacote SQ.Colunas.Bancos de dados;

importação com.strategyquant.lib.L;
import com.strategyquant.lib.SQUtils;
Importar com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

importação java.util.list;
importação java.util.arrayList;
importação de java.util.*;
importação de java.lang.*;

// Mode na França por Emmanuel Evrard para a StrategyQuantX Community :)
classe pública BiggestMAEallHedgingTrade estende Banco de DadosColuna
{
    público BiggestMAEallHedgingTrade()
    {
        super(L.tsq("Biggest Multiple Hedging MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Biggest Multiple Hedging MAE - is the worst Maximum Adverse Excursion of all trades open at once"));
    }
    
    //------------------------------------------------------------------------

    @Override
    duplo cálculo público(SQStats stats, StatsTypeCombinação, OrderList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) lança Exceção
    {
        duplo piorMAE1= -Double.MAX_VALUE;
        duplo piorMAE2 = -Duplo.MAX_VALUE;
        duplo BesttMFE1= -Duplo.MAX_VALUE;

        Data = nova Data();
        Data DataTemp = nova Data();
        duplo Total1 = 0;
        duplo Tamanho1 = 0;
        direção int = 0;

        for(int i = 0; i  piorMAE1)
                {
                    piorMAE1 = (Total1/ordem.Tamanho);
                }
            }
        }

        Total1 = 0;
        for(int i = 0; i  piorMAE2)
                {
                    piorMAE2 = (Total1/ordem.Tamanho);
                }
            }
        }
        
        se (piorMAE1 >= piorMAE2)
        {
            Total1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Total1/ordem.Tamanho);
                    }
                }
            }

            retorno -1*(piorMAE1 - BesttMFE1);
        }
        senão se (worstMAE2 > worstMAE1)
        {
            Total1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Total1/ordem.Tamanho);
                    }
                }
            }

            retorno -1*(piorMAE2 - BesttMFE1);
        }
        retornar 0;
    }
}

pacote SQ.Colunas.Bancos de dados;

importação com.strategyquant.lib.L;
import com.strategyquant.lib.SQUtils;
Importar com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;

importação java.util.list;
importação java.util.arrayList;
importação de java.util.*;
importação de java.lang.*;

// Mode na França por Emmanuel Evrard para a StrategyQuantX Community :)
classe pública BiggestMAEallHedgingTradePct estende Banco de DadosColuna
{
    público BiggestMAEallHedgingTradePct()
    {
        super(L.tsq("Biggest Multiple Hedging MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(100);
        setTooltip(L.tsq("Biggest Multiple Hedging MAE % - é a pior Excursão Máxima Adversa de todas as operações abertas de uma só vez em comparação com AccountBalance"));
    }
    
    @Override
    duplo cálculo público(SQStats stats, StatsTypeCombinação, OrderList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) lança Exceção
    {
        duplo piorMAE1= -Double.MAX_VALUE;
        duplo piorMAE2 = -Duplo.MAX_VALUE;
        duplo BesttMFE1= -Duplo.MAX_VALUE;
        Data = nova Data();
        Data DataTemp = nova Data();
        duplo Total1 = 0;
        duplo Total2 = 0;
        direção int = 0;

        for(int i = 0; i piorMAE1)
                {
                    piorMAE1 = Total2;
                }
            }
        }

        Total1 = 0;
        for(int i = 0; i piorMAE2)
                {
                    piorMAE2 = Total2;
                }
            }
        }

        se (piorMAE1 >= piorMAE2)
        {
            Total1 = 0;
            for(int i = 0; i BesttMFE1)
                    {
                        BesttMFE1 = Total2;
                    }
                }
            }

            retorno -1*(piorMAE1 - BesttMFE1);
        }
        senão se (worstMAE2 > worstMAE1)
        {
            Total1 = 0;
            for(int i = 0; i BesttMFE1)
                    {
                        BesttMFE1 = Total2;
                    }
                }
            }
            retorno -1*(piorMAE2 - BesttMFE1);
        }
        retornar 0;
    }
}