Erkennen von Ergebnissen in der WF-Matrix um das benutzerdefinierte Feld

Der ursprüngliche Antrag:

Gibt es eine Möglichkeit, eine bestimmte Zelle im WFM auszuwählen, die eine bestimmte Anzahl von benachbarten Zellen haben muss?
D.h. ich möchte einen bestandenen WFM haben, wenn 4 Zellen, die die 10 Runs und 20%OOS Zelle umgeben, ein bestandenes Ergebnis haben. Ich möchte nicht, dass SQX die beste Zelle anhand der Ergebnisse in der Umgebung auswählt, sondern ich möchte festlegen, welche Zelle ich in der Umgebung der bestandenen Zellen haben muss.

Ja, das ist möglich. Am einfachsten geht es mit dem Snippet Custom Analysis, das direkt nach der Optimierung gestartet werden kann.

Kommentierter Code des CustomAnalysis-Snippets:

Paket SQ.CustomAnalysis;

import org.slf4j.Logger;
importieren 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("CA WFM Prüfung", TYPE_FILTER_STRATEGY);
    }
    
    //------------------------------------------------------------------------
    
    @Override
    public boolean filterStrategy(String project, String task, String databankName, ResultsGroup rg) throws Exception {

        // Wie viele Nachbarn müssen passen, damit die WF-Matrix passt?
        int neighboursToPass = 3;

        // Finde das gewünschte WF-Ergebnis in der Strategie ResultsGroup - in unserem Fall 10 Runs und 20% OOS
        WalkForwardResult wfResult;
        try {
            wfResult = findWFResult(rg, 20, 10); // 10 Runs und 20%OOS
        } catch(Exception e) {
            Log.info("WFResult nicht gefunden: " + e.getMessage());

            return true;
        }

        // WFM-Matrix als zweidimensionales Array erstellen
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        WalkForwardResult[][] wfMatrix = createMatrix(wfm);
        
        int matrixRows = wfMatrix.length;
        int matrixColumns = wfMatrix[0].length;

        // Gehen Sie nun durch dieses zweidimensionale Array und suchen Sie nach den Nachbarn des von uns gewählten WF-Ergebnisses
        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) {
                    //WF-Ergebnisposition in der Matrix gefunden, Nachbarn prüfen
                    int neighboursPassed = 0;
                    int neighboursChecked = 0;
                    
                    for(int neighbourRowIndex=rowIndex-1; neighbourRowIndex<=rowIndex+1; neighbourRowIndex++) {
                        if(neighbourRowIndex=matrixRows) {
                            weiter;
                        }
                        
                        for(int neighbourColIndex=colIndex-1; neighbourColIndex<=colIndex+1; neighbourColIndex++) {
                            if(neighbourColIndex=matrixColumns) {
                                weiter;
                            }
                            
                            if(neighbourRowIndex==rowIndex && neighbourColIndex==colIndex) {
                                fortfahren;
                            }
                            
                            WalkForwardResult wfResultNeighbour = wfMatrix[neighbourRowIndex][neighbourColIndex];
                            if(wfResultNeighbour.passed) {
                                neighboursPassed++;
                            }
                            
                            neighboursChecked++;
                        }
                    }
                    
                    Log.info(String.format("Neighbours checked %d / passed %d", neighboursChecked, neighboursPassed));

                    // fand die WF Ergebnis, bestanden Nachbarn geprüft. Mit Schwellenwert vergleichen
                    return 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 nicht gefunden.");
        }
        
        return wfm.getWFResult(param1, param2);
    }
    
    //------------------------------------------------------------------------

    private WalkForwardResult[][] createMatrix(WalkForwardMatrixResult wfm) throws Exception {
        int rows = 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;
        
        for(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;
        }
        
        return wfMatrix;
    }
}