Analisi del commercio - Rapporto di vantaggio medio per ora

I grafici di analisi del trade sono una parte dei risultati di StrategQuant X che ci permette di analizzare visivamente alcune proprietà di una strategia. Nel seguente tutorial vi mostreremo come creare uno snippet analitico che ci mostri visivamente l'edge ratio medio di una strategia in funzione dell'ora di apertura dell'operazione.

È possibile scaricare lo snippet finito qui.

Passo 1 - Aprire l'editor di codice

Fare clic sull'icona dell'editor di codice per passare all'editor.

Passo 2 - Creare una nuova colonna Commercio

Aprire CodeEditor, fare clic su Crea nuovo e scegliere l'opzione Grafico di analisi del commercio. Rapporto di margine per ora. Questo creerà un nuovo snippet AvgEdgeRatioByHour.java in cartella Utente/Snippets/SQ/TradeAnalysis Nel costruttore si definisce il nome da visualizzare.

public class AvgEdgeRatioByHour extends TradeAnalysisChart {

    public AvgEdgeRatioByHour() {
        this.name = L.tsq("Avg.Edge Ratio By Hour");
    }

Passo 3 - Modificare il metodo di disegno

In questo metodo si specifica il tipo di grafico che si vuole creare. Possiamo scegliere tra le seguenti opzioni

• Grafico a barre
• Grafico a dispersione
• Grafico dei prezzi

Quindi si crea un array in cui inserire i dati dell'array computeData. Utilizzare il ciclo for per aggiungere al grafico i valori calcolati nell'array computeData.

@Override
    public AbstractChart draw(OrdersList orders, byte plType, byte tradePeriod) {
        // creazione di una nuova istanza di grafico
        BarChart chart = new BarChart();
        
        chart.invertIfNegative(true);
        
        if(ordini==null) {
            restituisce il grafico;
        }
        // creiamo un array in cui memorizzare i dati calcolati nel metodo computeData
        double[] hours = computeData(orders, plType, tradePeriod);
        
        // riempiamo il grafico con i valori dell'array
        for(int hour=0; hour<hours.length; hour++) {
            
            chart.addValue(L.tsq("Avg.Edge Ratio By Hour"), hour, hours[hour]/hoursCount[hour]);
        }

        return chart;
    }

Passo 4 - Implementare l'array computeData

private double[] computeData(OrdersList orders, byte plType, byte tradePeriod) {
        double[] hours = new double[24];
        
        for(int hour=0; hour<hours.length; hour++) {
            ore[ora]=0;
        }
        
        int ora;
        // qui lavoriamo con l'elenco degli ordini
        for(int i = 0; i < orders.size(); i++) {
            Ordine = orders.get(i);
            
            hour = SQTime.getHour(order.getTimeByPeriodType(tradePeriod)); //0-23

            double mae = order.PipsMAE; //ottenere il MAE dell'ordine in pips
            double mfe = order.PipsMFE; //ottenere il MAE dell'ordine in pips
            double atrOnOpen = order.ATROnOpen; //ottenere l'ATR dell'ordine in pips

            double normMAE = mae/atrOnOpen; // ottiene il MAE normalizzato
            double normMFE = mfe/atrOnOpen; // ottiene la MFE normalizzata

            double eRTrade = SQUtils.safeDivide(normMFE,normMAE); // SQUtils.safeDivide precede l'eccezione di divisione zero nulla


            ore[ora]+= eRTrade;
            hoursCount[hour]+=1;
        }

Fase 5 - Utilizzo Avg. Rapporto di vantaggio per ora nella strategia Quant X

Dopo aver compilato lo snippet e riavviato Code Editor e StrategyQUant X, possiamo lavorare con lo snippet appena creato.

Codice commentato

pacchetto SQ.TradeAnalysis;
importare com.strategyquant.lib.*;
importare com.strategyquant.datalib.*;
importare com.strategyquant.tradinglib.*;

public class AvgEdgeRatioByHour extends TradeAnalysisChart {
    // Costruttore della classe in cui si definisce il nome dello snippet
    public AvgEdgeRatioByHour() {
        this.name = L.tsq("Avg.Edge Ratio By Hour");
    }
    
    @Override
    public AbstractChart draw(OrdersList orders, byte plType, byte tradePeriod) {
        // creazione di una nuova istanza di grafico
        BarChart chart = new BarChart();
        
        chart.invertIfNegative(true);
        
        if(ordini==null) {
            restituisce il grafico;
        }
        // creiamo un array in cui memorizzare i dati calcolati nel metodo computeData
        double[] hours = computeData(orders, plType, tradePeriod);
        
        // riempiamo il grafico con i valori dell'array
        for(int hour=0; hour<hours.length; hour++) {
            // ore[ora]/conteggio ore[ora] calcoliamo l'Edge Ratio medio per ora
            chart.addValue(L.tsq("Avg.Edge Ratio By Hour"), hour, hours[hour]/hoursCount[hour]);
        }

        return chart;
    }
    // creare un array per il conteggio degli scambi
    int [] hoursCount = new int[24];
     
    private double[] computeData(OrdersList orders, byte plType, byte tradePeriod) {
        //creare un array in cui memorizzare i risultati calcolati
        double[] hours = new double[24];
        // imposta i valori allo stato predefinito 0
        for(int hour=0; hour<hours.length; hour++) {
            ore[ora]=0;
        }
        
        int hour;
        // qui lavoriamo con gli ordini della lista OrdersList
        for(int i = 0; i < orders.size(); i++) {
            Ordine = orders.get(i);
            
            hour = SQTime.getHour(order.getTimeByPeriodType(tradePeriod)); //0-23

            double mae = order.PipsMAE; //ottenere il MAE dell'ordine in pips
            double mfe = order.PipsMFE; //ottenere il MAE dell'ordine in pips
            double atrOnOpen = order.ATROnOpen; //ottenere l'ATR dell'ordine in pips

            double normMAE = mae/atrOnOpen; // ottiene il MAE normalizzato
            double normMFE = mfe/atrOnOpen; // ottiene la MFE normalizzata

            double eRTrade = SQUtils.safeDivide(normMFE,normMAE); // SQUtils.safeDivide precede l'eccezione di divisione zero nulla

            // memorizzare l'edge ratio per ogni ora
            ore[ora]+= eRTrade;
            // conta il numero di scambi per ogni ora
            hoursCount[hour]+=1;
        }

        return hours;
    }
}