Análisis de operaciones - Ratio de ventaja media por hora

Trade Analysis Charts es una parte de los resultados de StrategQuant X que nos permite analizar visualmente algunas propiedades de una estrategia. En el siguiente tutorial, le mostraremos cómo crear un fragmento analítico que nos muestre visualmente el ratio de borde medio de una estrategia en función de la hora de apertura de la operación.

Puede descargar el fragmento terminado aquí.

Paso 1 - Abrir el editor de código

Haga clic en el icono Editor de código para cambiar al Editor.

Paso 2 - Crear una nueva columna Comercio

Abra CodeEditor, haga clic en Crear nuevo y elija la opción Gráfico de análisis comercial. AvgEdgeRatioByHour. Esto creará un nuevo fragmento AvgEdgeRatioByHour.java en carpeta Usuario/Snippets/SQ/TradeAnalysis En el constructor definimos el nombre que se mostrará.

public clase AvgEdgeRatioByHour extends TradeAnalysisChart {

    public RatioAvgEdgePorHora() {
        this.name = L.tsq("Relación de flancos media por hora");
    }

Paso 3 - Modificar el método de dibujo

En este método especificamos el tipo de gráfico que queremos crear. Podemos elegir entre las siguientes opciones

• Gráfico de barras
• Gráfico de dispersión
• Gráfico de precios

A continuación se crea un array en el que se insertan los datos del array computeData. Utiliza el bucle for para añadir al gráfico los valores calculados en la matriz computeData.

@Override
    public AbstractChart draw(OrdersList orders, byte plType, byte tradePeriod) {
        // crear nueva instancia de gráfico
        BarChart gráfico = new BarChart();
        
        chart.invertIfNegative(true);
        
        if(pedidos==nulo) {
            return gráfico;
        }
        // creando array aquí almacenamos los datos calculados en el método computeData
        double[] horas = computeData(orders, plType, tradePeriod);
        
        // rellenar el gráfico con los valores del array
        for(int hora=0; hora<hora.longitud; hora++) {
            
            chart.addValue(L.tsq("Ratio de margen medio por hora"), hour, hours[hour]/hoursCount[hour]);
        }

        return gráfico;
    }

Paso 4 - Implementar la matriz computeData

private double[] computeData(OrdersList orders, byte plType, byte tradePeriod) {
        double[] horas = new double[24];
        
        for(int hora=0; hora<hora.longitud; hora++) {
            horas[hora]=0;
        }
        
        int hora;
        // aquí trabajamos con orderslist
        for(int i = 0; i < pedidos.tamaño(); i++) {
            Pedido = pedidos.get(i);
            
            hora = SQTime.getHour(order.getTimeByPeriodType(tradePeriod)); //0-23

            double mae = orden.PipsMAE; //obtener el MAE de la orden en pips
            double mfe = order.PipsMFE; //obtener el MAE de la orden en pips
            double atrOnOpen = order.ATROnOpen; //obtiene el ATR de la orden en pips

            double normMAE = mae/atrOnOpen; // obtiene la MAE normalizada
            double normMFE = mfe/atrOnOpen; // obtiene el MFE normalizado

            double eRTrade = SQUtils.safeDivide(normMFE,normMAE); // SQUtils.safeDivide precede a la excepción null zero divide


            horas[hora]+= eRTrade;
            hoursCount[hour]+=1;
        }

Paso 5 - Utilización Ratio Avg. Ratio de ventaja por hora en la estrategia Quant X

Después de compilar el snippet y reiniciar Code Editor y StrategyQUant X podemos trabajar con el snippet recién creado.

Código comentado

paquete SQ.TradeAnalysis;
import com.strategyquant.lib.*;
import com.strategyquant.datalib.*;
import com.strategyquant.tradinglib.*;

public class AvgEdgeRatioByHour extends TradeAnalysisChart {
    // Constructor de la clase donde definimos el nombre del fragmento
    public AvgEdgeRatioByHour() {
        this.name = L.tsq("Avg.Edge Ratio By Hour");
    }
    
    @Override
    public AbstractChart draw(OrdersList orders, byte plType, byte tradePeriod) {
        // crear nueva instancia de gráfico
        BarChart gráfico = new BarChart();
        
        chart.invertIfNegative(true);
        
        if(pedidos==nulo) {
            return gráfico;
        }
        // creamos un array donde almacenamos los datos calculados en el método computeData
        double[] hours = computeData(orders, plType, tradePeriod);
        
        // rellenar el gráfico con los valores del array
        for(int hora=0; hora<horas.longitud; hora++) {
            // hours[hour]/hoursCount[hour] calculamos el Edge Ratio medio por hora
            chart.addValue(L.tsq("Promedio Edge Ratio Por Hora"), hour, hours[hour]/hoursCount[hour]);
        }

        return gráfico;
    }
    // crear matriz para contar operaciones
    int [] hoursCount = new int[24];
     
    private double[] computeData(OrdersList orders, byte plType, byte tradePeriod) {
        //crea un array donde almacenar los resultados calculados
        double[] horas = new double[24];
        // establecer valores por defecto estado 0
        for(int hora=0; hora<hora.longitud; hora++) {
            horas[hora]=0;
        }
        
        int hora;
        // aquí trabajamos con OrdersList orders
        for(int i = 0; i < pedidos.tamaño(); i++) {
            Pedido pedido = pedidos.get(i);
            
            hora = SQTime.getHour(order.getTimeByPeriodType(tradePeriod)); //0-23

            double mae = orden.PipsMAE; //obtener el MAE de la orden en pips
            double mfe = order.PipsMFE; //obtener el MAE de la orden en pips
            double atrOnOpen = order.ATROnOpen; //obtiene el ATR de la orden en pips

            double normMAE = mae/atrOnOpen; // obtiene la MAE normalizada
            double normMFE = mfe/atrOnOpen; // obtiene el MFE normalizado

            double eRTrade = SQUtils.safeDivide(normMFE,normMAE); // SQUtils.safeDivide precede a la excepción null zero divide

            // almacenar ratio de borde para cada hora
            horas[hora]+= eRTrade;
            // cuenta el número de operaciones por cada hora
            hoursCount[hour]+=1;
        }

        return horas;
    }
}