Mayor MAE en operaciones múltiples

Tenemos un fragmento "Mayor MAE".
Es muy útil para ver cómo se comporta una estrategia con una sola orden.

Por experiencia, me he dado cuenta a menudo de que es más eficaz trabajar con una cesta de órdenes que con una sola orden. Por ejemplo, es más prudente distribuir 1 % de riesgo en una cesta de órdenes, en lugar de los 1% completos en una sola orden.

Con una cesta u órdenes, tiene más flexibilidad, ya que puede elegir varias posiciones de entrada. No tiene que fijar una única posición de entrada.

Si abre varios pedidos a la vez, hay que calcular el MAE total de todas las posiciones abiertas.

Este cálculo es necesario si abre todas las posiciones en la misma dirección. (ninguna posición de cobertura)

Propongo aquí dos fragmentos : 

La primera : "BiggestMAEallTrade", le está dando el mayor MAE para UN contrato.  Hice el cálculo para un contrato para obtener resultados precisos aunque la estrategia aumente el tamaño del contrato durante el periodo de la muestra.

A partir de estos resultados, usted tiene una buena idea, si usted trabaja con 0,1 tamaño del contrato, por ejemplo.

paquete SQ.Columns.Databanks;

import com.strategyquant.lib.L;
import 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.lang.*;

// Modo en Francia por Emmanuel Evrard para la Comunidad StrategyQuantX :)
public class BiggestMAEallTrade extends DatabankColumna
{
    public BiggestMAEallTrade()
    {
        super(L.tsq("Mayor MAE Múltiple"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Mayor Múltiplo MAE - es la peor Excursión Máxima Adversa de todas las operaciones abiertas a la vez"));
    }
    
    //------------------------------------------------------------------------

    @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 Tamaño1 = 0;

        for(int i = 0; i peorMAE)
            {
                worstMAE = (Total1 / tamaño1);
            }
        }
        
        return -1*peorMAE;
    }
}

El segundo : "MayorPorcentajeDeCompraEnTodo"da el mayor MAE en comparación con AccountBalanceEsto es interesante para ver si una estrategia utiliza poco o necesita demasiado del Saldo de la cuenta.

Si tiene un 5% Pérdida diaria máxima...puedes ver si estás por encima o por debajo.

paquete SQ.Columns.Databanks;

import com.strategyquant.lib.L;
import 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.lang.*;

// Modo en Francia por Emmanuel Evrard para la Comunidad StrategyQuantX :)
public class MayorMaTodoPorCambio extends DatabankColumn
{
    public BiggestMAEallTradePct()
    {
        super(L.tsq("Mayor MAE Múltiple %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(70);
        setTooltip(L.tsq("Mayor Múltiplo MAE % - es la peor Excursión Máxima Adversa de todas las operaciones abiertas a la vez comparada con 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 Total2 = 0;

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

        return -1*worstMAE;
    }
}

Si tiene varias posiciones en direcciones opuestas, alcistas y bajistas, en este caso, podría ser interesante tener un cálculo diferente:

Tomé el MAE mayor y restar el MFE de la dirección opuesta para obtener el MAE global de este MAE mayor.

Esto funciona sólo si las operaciones opuestas están abiertas durante el MAE mayor y no después. Sin embargo este cálculo puede ser útil.

Hice estas modificaciones en fragmentos BiggestMAEallHedgingTrade y MayorMaTodoComercioPct

paquete SQ.Columns.Databanks;

import com.strategyquant.lib.L;
import 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.lang.*;

// Modo en Francia por Emmanuel Evrard para la Comunidad StrategyQuantX :)
public class BiggestMAEallHedgingTrade extends DatabankColumna
{
    public MayorMAEtodoHedgingTrade()
    {
        super(L.tsq("Mayor MAE de Cobertura Múltiple"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);

        setWidth(140);
        
        setTooltip(L.tsq("Mayor MAE de cobertura múltiple - es la peor Excursión Adversa Máxima de todas las operaciones abiertas a la vez"));
    }
    
    //------------------------------------------------------------------------

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

        Date date = new Date();
        date dateTemp = new Date();
        double Total1 = 0
        double Tamaño1 = 0
        int dirección = 0;

        for(int i = 0; i  peorMAE1)
                {
                    peorMAE1 = (Total1/Tamaño1);
                }
            }
        }

        Total1 = 0;
        for(int i = 0; i  peorMAE2)
                {
                    peorMAE2 = (Total1/Tamaño1);
                }
            }
        }
        
        si (peorMAE1 >= peorMAE2)
        {
            Total1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Total1/orden.Tamaño);
                    }
                }
            }

            return -1*(peorMAE1 - BesttMFE1);
        }
        else if (worstMAE2 > worstMAE1)
        {
            Total1 = 0;
            for(int i = 0; i  BesttMFE1)
                    {
                        BesttMFE1 = (Total1/orden.Tamaño);
                    }
                }
            }

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

paquete SQ.Columns.Databanks;

import com.strategyquant.lib.L;
import 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.lang.*;

// Modo en Francia por Emmanuel Evrard para la Comunidad StrategyQuantX :)
public class MayorCantidadDeTrabajo extends DatabankColumn
{
    public MayorCantidadDeTrafico()
    {
        super(L.tsq("Mayor Cobertura Múltiple MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
        setWidth(100);
        setTooltip(L.tsq("Mayor Cobertura Múltiple MAE % - es la peor Excursión Máxima Adversa de todas las operaciones abiertas a la vez comparada con AccountBalance"));
    }
    
    @Override
    public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
    {
        double peorMAE1= -Doble.MAX_VALOR;
        double peorMAE2 = -Doble.MAX_VALOR;
        double BesttMFE1= -Double.MAX_VALUE;
        Date date = new Date();
        date dateTemp = new Date();
        double Total1 = 0;
        double Total2 = 0;
        int dirección = 0;

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

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

        if (worstMAE1 >= worstMAE2)
        {
            Total1 = 0;
            for(int i = 0; i BesttMFE1)
                    {
                        BesttMFE1 = Total2;
                    }
                }
            }

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