Reconocimiento de resultados en WF Matrix alrededor del campo personalizado

La petición original:

¿hay alguna forma de elegir una celda específica en WFM que un cierto número de celdas circundantes tienen que tener Pass?
Por ejemplo, quiero tener un WFM aprobado si 4 celdas que rodean la celda 10 Runs y 20%OOS tienen un resultado aprobado. No quiero que SQX elija la mejor celda según los resultados circundantes, sino que quiero definir qué celda necesito que rodee a las celdas aprobadas.

Sí, es posible, la forma más fácil de hacerlo es utilizando el fragmento de análisis personalizado que se puede iniciar justo después de la optimización.

Código del fragmento CustomAnalysis comentado:

paquete SQ.CustomAnalysis;

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

        // ¿cuántos vecinos deben pasar para que pase la matriz WF?
        int vecinosPasar = 3;

        // encontrar el resultado WF deseado en la estrategia ResultsGroup - en nuestro caso 10 Runs y 20% OOS
        WalkForwardResult wfResult;
        try {
            wfResult = findWFResult(rg, 20, 10); // 10 carreras y 20%OOS
        } catch(Exception e) {
            Log.info("No se ha encontrado WFResult: " + e.getMessage());

            return true;
        }

        // crear matriz WFM como matriz bidimensional
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        WalkForwardResult[][] wfMatrix = createMatrix(wfm);
        
        int matrizFilas = wfMatriz.longitud;
        int matrixColumns = wfMatrix[0].length;

        // ahora recorre esta matriz bidimensional y busca los vecinos de nuestro resultado WF elegido
        for(int filaIndex=0; filaIndex<matrizFilas; filaIndex++) {
            for(int colIndex=0; colIndex<matrixColumns; colIndex++) {
                
                if(wfMatrix[rowIndex][colIndex].param1 == wfResult.param1 && wfMatrix[rowIndex][colIndex].param2 == wfResult.param2) {
                    //Posición del resultado WF encontrada en la matriz, comprobar vecinos
                    int vecinosPasados = 0;
                    int vecinosComprobados = 0;
                    
                    for(int neighborRowIndex=rowIndex-1; neighbourRowIndex<=rowIndex+1; neighbourRowIndex++) {
                        if(neighborRowIndex=matrixRows) {
                            continuar;
                        }
                        
                        for(int neighborColIndex=colIndex-1; neighbourColIndex<=colIndex+1; neighbourColIndex++) {
                            if(neighborColIndex=matrixColumns) {
                                continuar;
                            }
                            
                            if(neighborRowIndex==rowIndex && neighbourColIndex==colIndex) {
                                continue;
                            }
                            
                            WalkForwardResult wfResultNeighbour = wfMatrix[neighborRowIndex][neighbourColIndex];
                            if(wfResultNeighbour.passed) {
                                vecinosPasados++;
                            }
                            
                            neighboursChecked++;
                        }
                    }
                    
                    Log.info(String.format("Vecinos comprobados %d / aprobados %d", vecinosComprobados, vecinosAprobados));

                    // encontrado el resultado WF, vecinos comprobados pasados. Comparar con el valor umbral
                    return vecinosPasados >= vecinosPasados;
                }
            }
        }
        
        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 no encontrado.");
        }
        
        return wfm.getWFResult(param1, param2);
    }
    
    //------------------------------------------------------------------------

    private WalkForwardResult[][] createMatrix(WalkForwardMatrixResult wfm) throws Exception {
        int filas = 0
        int columnas = 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[filas][columnas];

        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;
    }
}