Riconoscimento dei risultati in WF Matrix intorno al campo personalizzato

La richiesta originale:

Esiste un modo per scegliere una cella specifica in WFM che deve avere un certo numero di celle circostanti?
Ad esempio, voglio che il WFM sia superato se 4 celle che circondano la cella 10 Runs e 20%OOS hanno un risultato superato. Non voglio che SQX scelga la cella migliore in base ai risultati circostanti, ma voglio invece definire quale cella devo avere intorno alle celle passate.

Sì, è possibile, il modo più semplice per farlo è utilizzare lo snippet Analisi personalizzata che può essere avviato subito dopo l'ottimizzazione.

Codice dello snippet CustomAnalysis commentato:

pacchetto SQ.CustomAnalysis;

importare org.slf4j.Logger;
importare org.slf4j.LoggerFactory;

import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;

public class CAWFMCheck extends CustomAnalysisMethod {
    public static final Logger Log = LoggerFactory.getLogger("CAWFMCheck");
    
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    
    public CAWFMCheck() {
        super("Controllo CA WFM", TYPE_FILTER_STRATEGY);
    }
    
    //------------------------------------------------------------------------
    
    @Override
    public boolean filterStrategy(String project, String task, String databankName, ResultsGroup rg) throws Exception {

        // quanti vicini devono passare perché WF Matrix passi?
        int neighboursToPass = 3;

        // troviamo il risultato WF desiderato nel ResultsGroup della strategia - nel nostro caso 10 Runs e 20% OOS
        WalkForwardResult wfResult;
        try {
            wfResult = findWFResult(rg, 20, 10); // 10 corse e 20%OOS
        } catch(Exception e) {
            Log.info("Risultato WFR non trovato: " + e.getMessage());

            return true;
        }

        // creare la matrice WFM come array bidimensionale
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        WalkForwardResult[][] wfMatrix = createMatrix(wfm);
        
        int matrixRows = wfMatrix.length;
        int matrixColumns = wfMatrix[0].length;

        // ora scorriamo questa matrice bidimensionale e cerchiamo i vicini del risultato WF scelto
        for(int rowIndex=0; rowIndex<matrixRows; rowIndex++) {
            for(int colIndex=0; colIndex<matrixColumns; colIndex++) {
                
                if(wfMatrix[rowIndex][colIndex].param1 == wfResult.param1 && wfMatrix[rowIndex][colIndex].param2 == wfResult.param2) {
                    /La posizione del risultato di wfResult è stata trovata nella matrice, controllare i vicini
                    int viciniPassati = 0;
                    int viciniControllati = 0;
                    
                    for(int neighbourRowIndex=rowIndex-1; neighbourRowIndex<=rowIndex+1; neighbourRowIndex++) {
                        if(neighbourRowIndex=matrixRows) {
                            continua;
                        }
                        
                        for(int neighbourColIndex=colIndex-1; neighbourColIndex<=colIndex+1; neighbourColIndex++) {
                            if(neighbourColIndex=matrixColumns) {
                                continua;
                            }
                            
                            se(neighbourRowIndex==rowIndex && neighbourColIndex==colIndex) {
                                continua;
                            }
                            
                            WalkForwardResult wfResultNeighbour = wfMatrix[neighbourRowIndex][neighbourColIndex];
                            if(wfResultNeighbour.passed) {
                                neighboursPassed++;
                            }
                            
                            neighboursChecked++;
                        }
                    }
                    
                    Log.info(String.format("Vicini controllati %d / superati %d", viciniControllati, viciniPassati));

                    // trovato il risultato WF, superati i vicini controllati. Confronto con il valore di soglia
                    restituire neighboursPassed >= neighboursToPass;
                }
            }
        }
        
        return false;
    }
    
    //------------------------------------------------------------------------
    
    private WalkForwardResult findWFResult(ResultsGroup rg, int param1, int param2) throws Exception {
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        if(wfm==null) {
            throw new Exception("WFMatrixResult non trovato.");
        }
        
        return wfm.getWFResult(param1, param2);
    }
    
    //------------------------------------------------------------------------

    private WalkForwardResult[][] createMatrix(WalkForwardMatrixResult wfm) throws Exception {
        int righe = 0;
        int columns = 0;

        for(int j=wfm.start2; j<=wfm.stop2; j+=wfm.increment2) rows++;
        for(int i=wfm.start1; i<=wfm.stop1; i+=wfm.increment1) columns++;
            
        WalkForwardResult[][] wfMatrix = new WalkForwardResult[rows][columns];

        int param1Index = 0;
        int param2Index = 0;
        
        per(int j=wfm.start2; j<=wfm.stop2; j+=wfm.increment2) {
            for(int i=wfm.start1; i<=wfm.stop1; i+=wfm.increment1) {
                WalkForwardResult wfResult = wfm.getWFResult(i, j);
              				
                wfMatrix[param2Index][param1Index] = wfResult;
                param1Index++;
            }
                        
            param2Index++;
            param1Index=0;
        }
        
        restituire wfMatrix;
    }
}